Go语言入门 #

var name type = expression

name := expression	//只能在函数里用

if exp{
	
}else if{

}else{

}

switch var1{
	case val1:
	case val2,val3:
	default:
}

switch{
	case exp1:
	case exp2:
	default:
}

for i:=0;i<10;i++{
	fmt.Println(i)
}

i:=1
for i<100{
	fmt.Println(i)
	i*=2
}

for{
	xxx
}

for i,v:=range Vals{
	fmt.Println(i,v)
}

func first(x int,_ int) int //预留参数

func test(a,b int) (int,err){ //多返回值
	xxx
}

func addSum(sum ... int)int{	//... 表示可变参数，可以传入无穷多个int，用for-range获取值
	var sum int
	for _,value := range nums{
		sum+=value
	}
	return sum
}

func f1(n int)int{
	if n==1{
		return 1
	}
	return f1(n-1)*n
}

func fib(n int) int{
	return fibter(1,0,n)
}
func fibter(a,b,count int)int{
	if count==0{
		return b	//不是返回上一层，而是直接退出函数
	}
	return fibter(a+b,a,count-1)
}

var arr [10]int
var arr2 [12]int{1,5:4,6,10:11,11}
var arr [13][13]int{}

var slice1 []int
var slice2 = []int{1,2,3,4}
var slice3 = []int{1,5:10,19:111}
var slice4 = make([]int,length,capacity) //capacity 可省略 容量爆了就翻倍2->4->8->16
slice2:=slice[1:4]	//截取，左闭右开，但cap=4，会复用相同底层结构，共享同一块内存

hash = f(key)
index = hash % array_size

package main

import "fmt"

type AnimalIF interface {
	Sleep()
	GetColor() string
	GetType() string
}

type Cat struct {
	color string
}

func (c *Cat) GetColor() string {
	return c.color
}

func (c *Cat) GetType() string {
	return "cat"
}

func (c *Cat) Sleep() {
	fmt.Println("Cat is Sleep")
}

type Dog struct {
	color string
}

func (d *Dog) Sleep() {
	fmt.Println("Dog is Sleep")
}

func (d *Dog) GetColor() string {
	return d.color
}

func (d *Dog) GetType() string {
	return "Dog"
}

func main() {
	var animal AnimalIF
	animal = &Cat{"Green"}
	animal.Sleep()
	animal = &Dog{"Red"}
	fmt.Println(animal.GetType())
	animal.Sleep()
}

package main

import "fmt"

type Flyer interface {
	fly()
}

type Swimmer interface {
	swim()
}
type FlyFish interface {
	Flyer
	Swimmer
}

type Fish struct {
}

func (fish Fish) fly() {
	fmt.Println("fly")
}

func (fish Fish) swim() {
	fmt.Println("swim")
}

func main() {
	var ff FlyFish
	ff = Fish{}
	ff.fly()
	ff.swim()
}

type Kind uint
const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

v:=reflect.Valueof(x)
return int(v.Int())

package main

import (
	"fmt"
	"reflect"
)

func reflectSetValue1(x interface{}) {
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Int64 {
		v.SetInt(200) //修改的是副本，reflect包会引发panic
	}
}
func reflectSetValue2(x interface{}) {
	v := reflect.ValueOf(x)
	// 反射中使用 Elem()方法获取指针对应的值
	if v.Elem().Kind() == reflect.Int64 {
		v.Elem().SetInt(200)
	}
}
func main() {
	var a int64 = 100
	// reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
	reflectSetValue2(&a)
	fmt.Println(a)
}

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int    `json:"id" ini:"s_id"`
	Name string `json:"name" ini:"s_name"`
	Age  int    `json:"score" ini:"s_score"`
	test interface{}
}

func (u User) Call(arg int) {
	fmt.Println(arg)
}

func main() {
	user := User{
		Id:   0,
		Name: "C++",
		Age:  3,
		test: 1131,
	}
	//user.Call()
	Do(user)
}

func Do(input interface{}) { //传指针加Elem()即可,加了Elem()必须要传指针
	t := reflect.TypeOf(input)
	v := reflect.ValueOf(input)
	fmt.Println("t is ", t)
	fmt.Println("v is ", v)
	for i := 0; i < t.NumField(); i++ { //t.Numfield==v.Numfield
		field := t.Field(i)
		value := v.Field(i)
		tag := t.Field(i).Tag.Get("json")
		fmt.Println("field is ", field, "\nvalue is ", value, "\ntag is ", tag)
	}
	fmt.Println("-------------------------------------------------------")
	for i := 0; i < v.NumMethod(); i++ {
		fmt.Println("i=", i)
		method := t.Method(i).Name
		var args = []reflect.Value{reflect.ValueOf(1)}
		fmt.Println(method)
		v.Method(i).Call(args)
	}
}

package main

import (
	"fmt"
	"sync"
)

// 声明全局等待组变量
var wg sync.WaitGroup

func hello() {
	fmt.Println("hello")
	wg.Done() // 告知当前goroutine完成
}

func main() {
	wg.Add(1) // 登记1个goroutine
	go hello()
	fmt.Println("你好")
	wg.Wait() // 阻塞等待登记的goroutine完成
}

func main(){
	runtime.GOMAXPROCS(i)
}

func recv(c chan int) {
	ret := <-c
	fmt.Println("接收成功", ret)
}

func main() {
	ch := make(chan int)
	go recv(ch) // 创建一个 goroutine 从通道接收值
	ch <- 10
	fmt.Println("发送成功")
}

value, ok := <- ch

package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Println("worker id: ", id, "doing job: ", job)
		results <- job * 2
		time.Sleep(time.Second)
		fmt.Println("worker id: ", id, "finished job: ", job)
	}
}

func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)

	for j := 0; j < 3; j++ {
		go worker(j, jobs, results)
	}

	for i := 0; i < 5; i++ {
		jobs <- i
	}
	close(jobs)

	for i := 0; i < 5; i++ {
		fmt.Println(<-results)
	}

}

package main

import "fmt"

func main() {
	ch := make(chan int, 1)

	for i := 0; i < 10; i++ {
		select { //如果多个case都满足，随机选一个执行
		case x := <-ch: //可以从channel中取值
			fmt.Println("Receiving", x)

		case ch <- i:
			fmt.Println("Sending ", i) //可以从channel中存放值
		default:
			fmt.Println("do nothing")
		}
	}
}

package main

import (
	"fmt"
	"sync"
)

// sync.Mutex

var (
	x int64
	wg sync.WaitGroup // 等待组
	m sync.Mutex // 互斥锁
)

// add 对全局变量x执行5000次加1操作
func add() {
	for i := 0; i < 5000; i++ {
		m.Lock() // 修改x前加锁
		x = x + 1
		m.Unlock() // 改完解锁
	}
	wg.Done()
}

func main() {
	wg.Add(2)

	go add()
	go add()

	wg.Wait()
	fmt.Println(x)
}

// 使用互斥锁，10并发写，1000并发读
do(writeWithLock, readWithLock, 10, 1000) // x:10 cost:1.466500951s

// 使用读写互斥锁，10并发写，1000并发读
do(writeWithRWLock, readWithRWLock, 10, 1000) // x:10 cost:117.207592ms

var wg sync.WaitGroup

func hello() {
	defer wg.Done()
	fmt.Println("Hello Goroutine!")
}
func main() {
	wg.Add(1)
	go hello() // 启动另外一个goroutine去执行hello函数
	fmt.Println("main goroutine done!")
	wg.Wait()
}

package singleton

import (
    "sync"
)

type singleton struct {}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	wg := sync.WaitGroup{}
	m := sync.Map{}
	for i := 0; i < 20; i++ {
		go func(i int) {
			wg.Add(1)
			m.Store(i, i+100)
			t, _ := m.Load(i)
			fmt.Println(i, ":", t)
			wg.Done()
		}(i)
	}
	wg.Wait()
}

var c sync.Cond
//协程A
c.L.Lock()
for !conditon(){
	c.Wait()
}
c.L.Unlock
//协程B
c.Broadcast()

go mod init modulename
go get modulename
go mod tidy

package main

import "fmt"

type Person struct {
	name string
	age  int
}

func NewPerson(name string, age int) (*Person, error) {
	if name == "" {
		return nil, fmt.Errorf("name is null")
	}
	if age < 0 {
		return nil, fmt.Errorf("age must be above 0")
	}
	return &Person{name, age}, nil
}

func main() {
	per, err := NewPerson("tom", -1)

	if err == nil {
		fmt.Println(per)
	} else {
		fmt.Println(err)
	}
}