golang踩坑:slice传参，for range赋值，goroutine闭包，append

一、slice的坑

案例：

查看以下代码会输出啥？

func main() {
  a := []int{7,8,9}
  fmt.Printf("len: %d cap:%d data:%+v\n", len(a), cap(a), a)
  ap(a)
  fmt.Printf("len: %d cap:%d data:%+v\n", len(a), cap(a), a)
}
 
func ap(a []int) {
  a[0] = 1
  a = append(a, 10)
}

答案：

len: 3 cap:3 data:[7 8 9]
len: 3 cap:3 data:[1 8 9]

解析：

这时ap后再输出a，会看到a[0]变成了1，但a的cap依然是3，看起来10并没有被append进去？原因很简单，Go中没有引用传递全是值传递，值传递意味着传递的是数据的拷贝，但是用的是一个地址

这实际上并不是匪夷所思，因为Go和C不一样，slice看起来像数组，实际上是一个结构体，在源码中的数据结构是：

type slice struct {
 array unsafe.Pointer
 len int
 cap int
}

这个结构体其实也很好理解，array是一个真正的数组指针，指向一段连续内存空间的头部，len和cap代表长度和容量。

可以把ap(a)替换成ap(array: 0x123, len: 3, cap: 3)，这样就比较好理解了，append修改的是数据的拷贝，但是a[0]=1修改的是地址的值

二、for range的坑

案例1：

type student struct {
 name string
 age  int
}
 
func main() {
 m := make(map[string]*student)
 stus := []student{
  {name: "小王子", age: 18},
  {name: "娜扎", age: 23},
  {name: "大王八", age: 9000},
 }
 
 // 这里出现问题
 for _, stu := range stus {
  m[stu.name] = &stu
 }
 for k, v := range m {
  fmt.Println(k, "=>", v.name)
 }
}

对于该代码，我们的预期结果是：

娜扎 => 娜扎
大王八 => 大王八
小王子 => 小王子

结果是：

小王子 => 大王八
娜扎 => 大王八
大王八 => 大王八

案例2：

func main() {
  arr1 := []int{1, 2, 3}
  arr2 := make([]*int, len(arr1))

  for i, v := range arr1 {
    arr2[i] = &v
  }

  for _, v := range arr2 {
    fmt.Println(*v)
  }
}

预期输出：

1
2
3

结果输出：

3
3
3

原因解析：

因为for range在遍历值类型时，其中的v变量是一个值的拷贝，当使用&获取指针时，实际上是获取到v这个临时变量的指针，而v变量在for range中只会创建一次，之后循环中会被一直重复使用，所以在arr2赋值的时候其实都是v变量的指针，而&v最终会指向arr1最后一个元素的值拷贝

三、Goroutine中捕获参数

goroutine中捕获的循环变量, 都为循环最后的值。

func main() {
 
    for i, v := range []string{"a", "b", "c", "d", "e"} {
        // goroutine中捕获循环变量
        go func() {
            fmt.Printf("index: %v, value: %v\n", i, v)
        }()
    }
 
    // 此处应该使用waitgroup实现, 为了简单使用了sleep
    time.Sleep(1 * time.Second)
 
}
 
//================输出==============
 
index: 4, value: e
index: 4, value: e
index: 4, value: e
index: 4, value: e
index: 4, value: e

原因：

goroutine中捕获的不是"值", 而是"有地址的变量". for循环可能会先结束, 之后各个goroutine才开始执行. 因此得到的是变量的最终值。

避免方式 在goroutine启动的函数中, 把变量作为参数捕获。

func main() {
 
    for i, v := range []string{"a", "b", "c", "d", "e"} {
        // 把循环变量作为参数传入
        go func(i int, v string) {
            // i, v是函数内部的局部变量
            fmt.Printf("index: %v, value: %v\n", i, v)
        }(i, v)
    }
 
    time.Sleep(1 * time.Second)
 
}
 
//================输出==============
 
index: 0, value: a
index: 1, value: b
index: 4, value: e
index: 3, value: d
index: 2, value: c

四、append踩坑

案例1：

package main

import "fmt"

type C struct {
	A []int
}

func main() {
	c := C{}
	c.B()
	c.C()
	fmt.Println(c.A)

}
func (receiver C) B() {
	receiver.A = append(receiver.A, 1)
	fmt.Println(receiver)

}
func (receiver C) C() {
	receiver.A = append(receiver.A, 2)
	fmt.Println(receiver)
}

输出：

{[1]}
{[2]}
[]

原因：receiver 是C的拷贝，所以，他的修改不影响原值，正确写法：改成指针接收者

package main

import "fmt"

type C struct {
	A []int
}

func main() {
	c := C{}
	c.B()
	c.C()
	fmt.Println(c.A)

}
func (receiver *C) B() {
	receiver.A = append(receiver.A, 1)
}
func (receiver *C) C() {
	receiver.A = append(receiver.A, 2)
}

案例2：

package main

import "fmt"

func main() {
	i := new([]string)
	a(i)
	b(i)
	fmt.Println(*i)
}
func a(i *[]string) {
	c := append(*i, "a")
	i = &c
}
func b(i *[]string) {
	c := append(*i, "b")
	i = &c

}

输出：[]

修改方法：i = &c