Go中slice做为参数传递的一些“坑”

看到这个题目，可能你们都以为是一个老生常谈的月经topic了。一直以来其实把握一个“值传递”基本上就能理解各类状况了，不过最近遇到了更深一点的“小坑”，与你们分享一下。

首先仍是从最简单的提及，看下面代码：

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 = append(a, 10)
}
复制代码

能够点击这里运行代码，以上代码的输出是什么呢？

我这里不卖关子了直接说，再调用ap函数进行append操做后，a依然是[]int{7,8,9}。缘由很简单，Go中没有引用传递全是值传递，值传递意味着传递的是数据的拷贝。这句话新手可能稍微有点云里雾里，而实际状况又比较诡异，好比说下面代码：

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)
}
复制代码

点击这里运行代码，这时ap后再输出a，会看到a[0]变成了1，但a的cap依然是3，看起来10并无被append进去？

这看起来就比较匪夷所思了，不是说值传递吗，为何仍是影响外部变量的值了呢？按理说要么都变要么都不变才说得过去啊。

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

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}
复制代码

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

换句话说，你看起来在代码里传参时写的是ap(a []int)，实际上在代码编译期，这段代码变成了ap(a runtime.slice)

你能够尝试这么理解，把ap(a)替换成ap(array: 0x123, len: 3, cap: 3)。能够很明显的看到，传递到ap函数的三个参数，仅仅是3个数值，并无和外部变量a创建任何引用关系。这即是值传递。

可是，你可能会疑惑，为何我改了a[0]的值，也会在外面体现呢？其实看到这里你应该已经能够本身想明白了，由于array是一个地址值(好比0x123)，这个地址传入了ap函数，可是它表明的地址0x123和外部a的0x123是一个内存地址，这时候你修改a[0]，其实是修改0x123地址中存放的值，因此外部固然会受影响了。

举个形象点的例子，假设你是火车站货物管理员，你管理的是第1到第3节车箱（车箱是互通的）的装卸货货。有一天你生病了，找我的（叫A）临时来接手一下。可是火车的货不是谁想碰就碰的，你得有证实才行。因而你把你手上的证实原件复印了一份给A，同时把第一节车箱的钥匙给A。因为恰好那几天比较忙，站长又让A也负责第四节车箱，因而A也获得了车箱4的证实原件。一段时间后，你生病回来，你依然只有1到3节车箱的证件，你能够看到最近A在1到3车箱搞的事情，可是你没有资格去4车箱。

以上例子应该能够很好的说明slice传参的场景，记住，Go中只有值传递。

是否是就完事儿了呢？然而事情并无这么简单。最近我工做时就遇到这个问题了。按照上面的举例，虽然你没有资格去查看4车箱，可是若是你好奇，你能够偷看啊，由于它们是连续的互通的，正如数组也是一段连续的内存，因而就有这样的代码：

func main() {
        a := []int{}
        a = append(a, 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)
        p := unsafe.Pointer(&a[2])
        q := uintptr(p)+8
        t := (*int)(unsafe.Pointer(q))
        fmt.Println(*t)
}

func ap(a []int) {
        a = append(a, 10)
}
复制代码

点击这里运行代码

虽然外部的cap和len并无改变，可是ap函数往同一段内存地址append了一个10，那我是否是能够用比较trick的方法去偷看呢？好比找到a[2]的地址，日后挪一个int的长度，就应该是ap函数新增的10了吧？这里须要注意，Go官网的server是32位的，因此在go playground执行这段代码时，int是4字节。

执行结果和我预想的同样！

可是问题接踵而至

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)
        p := unsafe.Pointer(&a[2])
        q := uintptr(p)+8
        t := (*int)(unsafe.Pointer(q))
        fmt.Println(*t)
}

func ap(a []int) {
        a = append(a, 10)
}
复制代码

这段代码你再试试？

这和上面一个例子惟一的区别就是slice一开始是用[]int{7,8,9}这种方式初始化。执行结果*t是3而不是10，这就比较困惑了。为啥？不是一段连续的内存空间吗？

这里其实涉及到的问题是slice的growth问题，当append时发现cap不够了，会从新分配空间，具体源码参见 runtime/slice.go中的growslice函数。我这里就不讲太多细节，只讲结果。当发生growslice时，会给slice从新分配一段更大的内存，而后把原来的数据copy过去，把slice的array指针指向新内存。也就是说，假如以前的数据是存放到内存地址 0x0 0x8 0x10，当不发生growslice，新append的数值会存到0x18，然而当发生growslice，之前的全部数据被copy到新的地址0x1000 0x1008 0x1010，新append的值放到0x1018了。

这时候你就能够理解为何有时候用unsafe能拿到数据，有时候拿不到了。或许你能够理解为何这个包叫作unsafe了。不过unsafe不是真的unsafe，是说若是你使用的姿式不对就很是容易unsafe。可是若是姿式优雅，其实很safe。对于slice操做，若是要使用unsafe，千万记得关注cap是否发送变化，它意味着内存的迁移