语言常见问题

这里列举的Go语言常见坑 是符合Go语言语法的，可以正常的编译，但是可能是运行结果错误，或者是有资源泄漏的风险。

另一些是与其他语言的不同思想对比，这里说“坑”指的是不同习惯的迁移感受可能是坑。

1 是否为空的简单对比思想

判断 list列表是否为空

golang:
    // 数组
    arr := [0]int{}
    if len(arr) == 0 {
        println(`这是个空数组`)
    }

    // 切片
    slice := make([]int, 0, 0)
    if len(slice) == 0 {
        println(`这是个空切片`)
    }

    切片默认值为 nil
    但不能使用 s == nil 判断是否为空
    应该使用 len(s) == 0

python:

    lisOne = []
    if lisOne:
        print("not empty")

1.1 BUG？ golang 计算问题： 无穷级数公式 求解值 无法完成计算的问题

对比计算实现时的bug

https://stackoverflow.com/questions/71499321 

1.2 BUG？ channel 的数据存入和取出

channel数据结构为 map[int]interface 时

var MyC = make(chan map[int]interface{}, 1000)

# ch <- map[int][]byte
byte := <- ch
byte  为 []byte 格式数据将无法正常转换为 string

# ch <-  map[int]string
strings := <-ch

strings 为 string格式时 可以取出正常转换为 string

1.3 channel中存入 对象

在channel中存入struct对象，运算符将改变编码

    如 "\u003e" "\u003e=" "\u003e="  "\u003c=" "\u003c"

2 golang 特征。断言的问题

https://golang.org/doc/faq#assertions

Go 不提供断言。不可否认，它们很方便，但我们的经验是，程序员将它们用作拐杖，以避免考虑正确的错误处理和报告。

正确的错误处理意味着服务器继续运行而不是在发生非致命错误后崩溃。

正确的错误报告意味着错误是直截了当的，使程序员免于解释大量的崩溃跟踪。

当看到错误的程序员不熟悉代码时，精确的错误尤为重要。

我们知道这是一个争论点。Go 语言和库中有许多与现代实践不同的地方，仅仅是因为我们觉得有时值得尝试不同的方法

2.1 功能性： golang 结构体：如何判断 一个 结构体是否被嵌套了

1 即是否有子类，或者在某个子类中被关联，嵌套。

2 保证我的类型满足接口？
您可以要求编译器检查该类型是否T实现了接口I，方法是根据需要尝试使用零值 T或指向的指针进行赋值T：

type T struct{}
var _ I = T{}       // 验证 T 实现了 I。
var _ I = (*T)(nil) // 验证 *T 实现了 I。

如果T（或*T相应地）没有实现 I，错误将在编译时被捕获

2.2 不支持的面向对象功能

    不支持 类型继承
    不支持 继承，  需要通过 interface 内联 实现
    不支持 方法重载 
    不支持 层次结构
组合，按需要的结构体关系，用户拥有更大使用空间。

2.3 BUG for 循环变量语义的迭代问题

    var all []*Item
    for _, item := range items {
        all = append(all, &item)
    }
也就是说，这段代码有一个错误。此循环执行后，all包含len(items)相同的指针，每个指针指向相同的Item，保存迭代的最后一个值。发生这种情况是因为 item 变量是每个循环，而不是每个迭代：&item在每次迭代中都是相同的，并且在每次迭代中都会item被覆盖。通常的解决方法是这样写：

    var all []*Item
    for _, item := range items {
        item := item
        all = append(all, &item)
    }

for each 的迭代参数不能即使更新的问题
https://github.com/golang/go/discussions/56010

2.4 函数的ABI规范调用问题

路径 ： 机器码 -> IR code -> ABI -> CLANG -> cgo -> API -> golang…

三 其他常见易犯的问题

1 可变参数是空接口类型

当参数的可变参数是空接口类型时，传人空接口的切片时需要注意参数展开的问题。

func main() {
    var a = []interface{}{1, 2, 3}

    fmt.Println(a)
    fmt.Println(a...)
}
不管是否展开，编译器都无法发现错误，但是输出是不同的：

[1 2 3]
1 2 3

数组是值传递

在函数调用参数中，数组是值传递，无法通过修改数组类型的参数返回结果。

func main() {
    x := [3]int{1, 2, 3}

    func(arr [3]int) {
        arr[0] = 7
        fmt.Println(arr)
    }(x)

    fmt.Println(x)
}
必要时需要使用切片。

map遍历是顺序不固定

map是一种hash表实现，每次遍历的顺序都可能不一样。

func main() {
    m := map[string]string{
        "1": "1",
        "2": "2",
        "3": "3",
    }

    for k, v := range m {
        println(k, v)
    }
}

返回值被屏蔽

在局部作用域中，命名的返回值内同名的局部变量屏蔽：

func Foo() (err error) {
    if err := Bar(); err != nil {
        return
    }
    return
}

recover必须在defer函数中运行

recover捕获的是祖父级调用时的异常，直接调用时无效：

func main() {
    recover()
    panic(1)
}
直接defer调用也是无效：

func main() {
    defer recover()
    panic(1)
}
defer调用时多层嵌套依然无效：

func main() {
    defer func() {
        func() { recover() }()
    }()
    panic(1)
}
必须在defer函数中直接调用才有效：

func main() {
    defer func() {
        recover()
    }()
    panic(1)
}

main函数提前退出

后台Goroutine无法保证完成任务。

func main() {
    go println("hello")
}
通过Sleep来回避并发中的问题
休眠并不能保证输出完整的字符串：

func main() {
    go println("hello")
    time.Sleep(time.Second)
}
类似的还有通过插入调度语句：

func main() {
    go println("hello")
    runtime.Gosched()
}

独占CPU导致其它Goroutine饿死

Goroutine是协作式抢占调度，Goroutine本身不会主动放弃CPU：

func main() {
    runtime.GOMAXPROCS(1)

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

    for {} // 占用CPU
}
解决的方法是在for循环加入runtime.Gosched()调度函数：

func main() {
    runtime.GOMAXPROCS(1)

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

    for {
        runtime.Gosched()
    }
}
或者是通过阻塞的方式避免CPU占用：

func main() {
    runtime.GOMAXPROCS(1)

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

    select{}
}

不同Goroutine之间不满足顺序一致性内存模型

因为在不同的Goroutine，main函数中无法保证能打印出hello, world:

var msg string
var done bool

func setup() {
    msg = "hello, world"
    done = true
}

func main() {
    go setup()
    for !done {
    }
    println(msg)
}
解决的办法是用显式同步：

var msg string
var done = make(chan bool)

func setup() {
    msg = "hello, world"
    done <- true
}

func main() {
    go setup()
    <-done
    println(msg)
}
msg的写入是在channel发送之前，所以能保证打印hello, world

闭包错误引用同一个变量

func main() {
    for i := 0; i < 5; i++ {
        defer func() {
            println(i)
        }()
    }
}
改进的方法是在每轮迭代中生成一个局部变量：

func main() {
    for i := 0; i < 5; i++ {
        i := i
        defer func() {
            println(i)
        }()
    }
}
或者是通过函数参数传入：

func main() {
    for i := 0; i < 5; i++ {
        defer func(i int) {
            println(i)
        }(i)
    }
}

在循环内部执行defer语句

defer在函数退出时才能执行，在for执行defer会导致资源延迟释放：

func main() {
    for i := 0; i < 5; i++ {
        f, err := os.Open("/path/to/file")
        if err != nil {
            log.Fatal(err)
        }
        defer f.Close()
    }
}
解决的方法可以在for中构造一个局部函数，在局部函数内部执行defer：

func main() {
    for i := 0; i < 5; i++ {
        func() {
            f, err := os.Open("/path/to/file")
            if err != nil {
                log.Fatal(err)
            }
            defer f.Close()
        }()
    }
}

切片会导致整个底层数组被锁定

切片会导致整个底层数组被锁定，底层数组无法释放内存。如果底层数组较大会对内存产生很大的压力。

func main() {
    headerMap := make(map[string][]byte)

    for i := 0; i < 5; i++ {
        name := "/path/to/file"
        data, err := ioutil.ReadFile(name)
        if err != nil {
            log.Fatal(err)
        }
        headerMap[name] = data[:1]
    }

    // do some thing
}
解决的方法是将结果克隆一份，这样可以释放底层的数组：

func main() {
    headerMap := make(map[string][]byte)

    for i := 0; i < 5; i++ {
        name := "/path/to/file"
        data, err := ioutil.ReadFile(name)
        if err != nil {
            log.Fatal(err)
        }
        headerMap[name] = append([]byte{}, data[:1]...)
    }

    // do some thing
}

空指针和空接口不等价

比如返回了一个错误指针，但是并不是空的error接口：

func returnsError() error {
    var p *MyError = nil
    if bad() {
        p = ErrBad
    }
    return p // Will always return a non-nil error.
}

同时注意nil被嵌套到空接口时，不等于空接口。 

内存地址会变化

Go语言中对象的地址可能发生变化，因此指针不能从其它非指针类型的值生成：

func main() {
    var x int = 42
    var p uintptr = uintptr(unsafe.Pointer(&x))

    runtime.GC()
    var px *int = (*int)(unsafe.Pointer(p))
    println(*px)
}
当内存发送变化的时候，相关的指针会同步更新，但是非指针类型的uintptr不会做同步更新。

同理CGO中也不能保存Go对象地址。

Goroutine泄露

Go语言是带内存自动回收的特性，因此内存一般不会泄漏。但是Goroutine存在泄漏，同时泄漏的Goroutine引用的内存同样无法被回收。

func main() {
    ch := func() <-chan int {
        ch := make(chan int)
        go func() {
            for i := 0; ; i++ {
                ch <- i
            }
        } ()
        return ch
    }()

    for v := range ch {
        fmt.Println(v)
        if v == 5 {
            break
        }
    }
}

上面的程序中后台Goroutine向管道输入自然数序列，main函数中输出序列。

但是当break跳出for循环的时候，后台Goroutine就处于无法被回收的状态了。

我们可以通过context包来避免这个问题：

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    ch := func(ctx context.Context) <-chan int {
        ch := make(chan int)
        go func() {
            for i := 0; ; i++ {
                select {
                case <- ctx.Done():
                    return
                case ch <- i:
                }
            }
        } ()
        return ch
    }(ctx)

    for v := range ch {
        fmt.Println(v)
        if v == 5 {
            cancel()
            break
        }
    }
}

当main函数在break跳出循环时，通过调用cancel()来通知后台Goroutine退出，这样就避免了Goroutine的泄漏。