go语言细节

1 数组与字符串为值类型，切片、映射、通道为值类型，赋值需注意。

package main

import (
    "fmt"
)

func main() {
    //数组
    a1 := [3]int{1, 2, 3}
    a2 := a1
    a2[0] = 2 
    fmt.Println(a1) //print: 1 2 3
    fmt.Println(a2) //print: 2 2 3
    // 字符串
    s1 := "123"
    s2 := s1
    s2 = "223"
    fmt.Println(s1) //print 123
    fmt.Println(s2) //print 223
    // 切片
    slice1 := []int{1, 2, 3}
    slice2 := slice1
    slice2[0] = 2 
    fmt.Println(slice1) //print 2 2 3
    fmt.Println(slice2) //print 2 2 3
    // map
    m1 := make(map[int]string)
    m1[1] = "1" 
    m2 := m1
    m2[1] = "2" 
    fmt.Println(m1) //print 1:2
    fmt.Println(m2) //print 1:2
    // chan
    c1 := make(chan bool)
    c2 := c1
    go func() {
        v := <-c2
        fmt.Println(v) //print true
    }() 
    c1 <- true
}

2 byte为uint8类型，string不是[]byte或[]rune类型。

package main

import (
    "fmt"
)

func main() {
    s := "hello world"
    var i interface{} = s 

    switch i.(type) {
    case []byte:
        fmt.Println("string type is []byte")
    case []rune:
        fmt.Println("string type is []rune")
    case []int8:
        fmt.Println("string type is []int8")
    }   

    slice := []byte{1, 2}
    i = slice
    switch i.(type) {
    case []uint8:
        fmt.Println("byte is uint8")//print 
    }   
}

3 接口为类型和值的二元组，nil类型为空且值为空。

package main

import (
    "fmt"
)

func trueNil() interface{} {
    return nil 
}

func falseNil() interface{} {
    var ret *int = nil // 此nil带有类型
    return ret 
}
func main() {
    if trueNil() == nil {
        fmt.Println("trueNil") //print trueNil
    }   

    if falseNil() == nil {
        fmt.Println("falseNil") //no print
    }   
}

 4 slice,map操作多协程需要加锁。

package main

import (
    "math/rand"
    "sync"
    "time"
)

func main() {
    Map := make(map[int]int)
    wg := &sync.WaitGroup{}

    for i := 0; i < 1000; i++ {
        go func() {
            wg.Add(1)
            defer wg.Done()
            for j := 0; j < 10000; j++ {
                Map[rand.Int()] = rand.Int()
                time.Sleep(time.Millisecond)
            }   
        }() 
    }   
    time.Sleep(time.Second * 5)
    wg.Wait()
    // 程序崩溃
}

 5 defer 调用函数时，函数在当前函数结束前调用，但传给调用函数的参数在defer所在行确定，而不在调用是确定。存在多个defer时，先出现后调用。

package main

import (
    "fmt"
)

type Data struct {
    data string
}

func Println(data Data) {
    fmt.Println(data.data)
}
func main() {
    data := Data{"world "}
    defer Println(data)
    data.data = "hello "
    defer Println(data)
    // 输出: hello world 而不是: hello hello 或 world hello
}