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

可变参数是空接口类型

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

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)

}

// [7 2 3]

// [1 2 3]

map遍历顺序是不固定的

map是一种hash表实现，每次遍历的顺序都可能不一样。Golang会提前取一个随机数，把桶的遍历顺序随机化。

func main() {

m := map[string]string{

"1": "1",

"2": "2",

"3": "3",

}

for k, v := range m {

println(k, v)

}

}

recover必须在defer函数中运行

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

直接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无法保证完成任务。

休眠：

time.Sleep(time.Second)

插入调度语句：

runtime.Gosched() //用于让出当前CPU时间片

利用for：

for {}

利用for+调度语句：

for {

runtime.Gosched()

}

利用阻塞：

select {}

闭包错误引用同一个变量

func main() {

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

defer func() {

println(i)

}()

}

}

/*

5

5

5

5

5

*/

改进的方法是在每轮迭代中生成一个局部变量

func main() {

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

i := i

defer func() {

println(i)

}()

}

}

/*

4

3

2

1

0

*/

或者是通过函数参数传入：

func main() {

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

defer func(i int) {

println(i)

}(i)

}

}

/*

4

3

2

1

0

*/

在循环内部执行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()

}()

}

}

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

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

headerMap[name] = data[:1]

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

eaderMap[name] = append([]byte{}, data[:1]...)

空指针和空接口不等价

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

内存地址会变化

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()

ch := make(chan int)

go func() {

for i := 0; ; i++ {

ch

}

} ()

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)

ch := make(chan int)

go func() {

for i := 0; ; i++ {

select {

case

return

case ch

}

}

} ()

return ch

}(ctx)

for v := range ch {

fmt.Println(v)

if v == 5 {

cancel()

break

}

}

}

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