少就是多，简单就是真理

简洁的变量声明和赋值

var i int = 9;
i := 9
i, j, k := 1, 2, 3
i, j, k := 1, 1.0, “hello”

var (
    a int
    b,c string
    d, e, f = 1, 2.0, "hello"
)

简洁的if

if i > 9 {
    println(“Greater then 9”)
}

result := SomeMethod()
if result > 0 {
  //
}

if result := SomeMethod(); result > 0 {
  
}

switch

switch tag {
    default: 
        method3()
    case 0, 1, 2:
        method1()
    case 3,4 , 5: 
        method2()
}
不需要 break

switch x := f(); {  
    case x < 0: return -x
    default: return x
}

switch {
    case x < y: f1()
    case x < z: f2()
    case x == 3: f3()
}



for i := 0; i < 10; i++ {

}

for a < b {

}

for {

}


count := len(someArray)
for i := 0; i < count; i++ {
    println(someArray[i])
}

range 关键字

for i, value := range someArray {

}

m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for i, s := range  m{
   
}


返回多个值

func returnTwoInt() (int, int) {

}

a, b := returnTwoInt()


函数内部声明的对象指针可以安全的返回

func ReturnPointer() *Object1 {
    obj := new Object1()
    obj.A = “hello”
    return obj
}


defer
func DoSomething() {
    if f, err := os.Open("xxx"); err == nil {
        defer f.Close()
        // ...?
    }
}
在当前函数(DoSomething)执行完毕之后执行

接口不需要显式实现
任何拥有某个接口所定义所有方法的东西，都默认实现了该接口
所有东西都默认实现 interface{}这个接口


多线程 异步

func IsReady(what string, seconds int64) { 
    time.Sleep(time.Duration(seconds)*time.Second); 
    fmt.Println(what, "is ready",time.Now()) 
} 

go IsReady("tea", 6); 
go IsReady("coffee", 2); 
fmt.Println("I'm waiting....");

I'm waiting.... (right away) 
coffee is ready (2 min later) 
tea is ready (6 min later)

异步方法 传递消息  channel
通道，一个往里写，另外一个等着读

ch := make(chan int) //创建一个传递整型的通道

func pump(ch chan int) { 
    for i := 0; ; i++ { ch <- i } //往通道里写值入
}

func suck(ch chan int) { 
    for { fmt.Println(<-ch) } // 取出
}

go pump(ch) // 异步执行pump

go suck(ch) // 异步执行suck

pump 泵
suck 吸