golang slice

关于golang slice有很多大神写了很多文章,阐述了slice的底层实现和使用中注意点.这篇文章是我参考https://www.calhoun.io/why-are-slices-sometimes-altered-when-passed-by-value-in-go/ 加了一些自己的总结。

• slice的实现原理,理解slice的实现原理是理解slice的一些很奇葩注意点的关键.一图胜千言.

image.png

如图所示slice的底层是一个array. slice是一个结构里面有2属性 len 和cap分别表示当前使用的个数和可以容纳的个数.

• example1

func main() {
    var s []int
    for i:=1;i<7;i++{
        s=append(s, i)
        //fmt.Printf("%p\n",s)
    }
    s2:=s[:]
    s1:=s[:]
    s1=append(s1,100)
    fmt.Printf("s1:%p len:%d,cap:%d\n",s1, len(s1), cap(s1))
    s2=append(s2, 100,200,300)
    fmt.Printf("s:%p len:%d,cap:%d\n",s, len(s), cap(s))
    fmt.Printf("s2:%p len:%d,cap:%d\n",s2, len(s2), cap(s2))
}

如上代码,先声明一len 0 cap 0的slice 然后往里面append元素.s的len和cap大概如下变化

len cap  s[i]         s 
0     0    0      
1     1    1       0xc42001a050
2     2    2       0xc42001a070
3     4    3       0xc420016140
4     4    4       0xc420016140
5     8    5       0xc420018100
6     8    6       0xc420018100

这个变化就是当cap不够时重新分配一个新的cap为当前cap的2倍的array. 注意右边的s指向的地址变化,每当重新分配新的array的时候s 指向的地址就会变化。

回到上面的main代码,如果使用切片生成一个新的slice s1 s2，注意这里s1 append 了一个元素,s2 append 3个元素.

s1:0xc420018100 len:7,cap:8
s:0xc420018100 len:6,cap:8
s2:0xc42008c000 len:9,cap:16

Process finished with exit code 0

这里s1指向的地址和s一样,只是len加1,因为s1只是append了一个元素,没有超出s的cap
s2 指向的地址和s不一样了,append3个元素超出了s的cap所以重新分配了一个数组

• example2

func main() {
    var s []int
    for i:=1;i<7;i++{
        s=append(s, i)
    }
    fmt.Printf("s point:%p  s len:%d s cap:%d %v\n",s,s, len(s), cap(s))
    reverse1(s)
    fmt.Printf("s point:%p  s len:%d s cap:%d %v\n",s,s, len(s), cap(s))
}
func reverse1(s[]int){
    for i,j:=0,len(s);i<j;i++{
        j=len(s)-(i+1)
        s[i],s[j]=s[j],s[i]
    }

}

func reverse2(s[]int){
    s=append(s, 8888,7777)
    for i,j:=0,len(s);i<j;i++{
        j=len(s)-(i+1)
        s[i],s[j]=s[j],s[i]
    }

}
func reverse3(s[]int){
    s=append(s, 8888,7777,1000)
    for i,j:=0,len(s);i<j;i++{
        j=len(s)-(i+1)
        s[i],s[j]=s[j],s[i]
    }

}

reverse1的输出

s point:0xc420018100  s len:[1 2 3 4 5 6] s cap:6 8
s point:0xc420018100  s len:[6 5 4 3 2 1] s cap:6 8

reverse2 的输出

s point:0xc420018100  s len:[1 2 3 4 5 6] s cap:6 8
s point:0xc420018100  s len:[7777 8888 6 5 4 3] s cap:6 8

reverse3 的输出

s point:0xc42008a040  s len:[1 2 3 4 5 6] s cap:6 8
s point:0xc42008a040  s len:[1 2 3 4 5 6] s cap:6 8

注意调用这3个函数后s的变化的差别
1. reverse1 只是将s中的元素顺序逆转了一下,只改变了元素的值。没有改变len cap.
2. reverse2 中给s append了一个元素,并且append之后的slice长度还是小于cap所有没有重新分配数组。注意这里append元素是不会改变main里面的s的len和cap的.
3 .reverse3 中append 3个元素超过cap,重新分配底层数组,所以reverse中的s2 指向的地址和main中的s分别指向2个不同的数组。所以逆转操作是发生在另外一个数组元素上而不是main的传进来的slice对应的数组上。

• golang中的值传递
  golang官方中明确指出golang中的所有的函数传参都是值传递.什么意思,即所有的传进函数方法的参数都是原来变量的拷贝.包括slice也是,有人说slice map channel是引用传递,其实是错误的,但是可以在函数中修改传入的参数的内容啊。
  如同刚才的slice的例子,传进来的s只是main总的一份拷贝, reverse1 中的s和main中的s得内存地址是不一样的。

s point:0xc42008a040  s len:[1 2 3 4 5 6] s cap:6 8
0xc420096020
0xc420096080
s point:0xc42008a040  s len:[6 5 4 3 2 1] s cap:6 8

只是slice里面指向的底层数组地址是同一个,所以reverse里面不管怎么改动,main里面的len cap pointer 都是不会被改变的。你只能改变pointer指向的数组的元素值

• 相似的类型

type A struct {
  Ptr1 *B
  Ptr2 *B
  Val B
}

type B struct {
  Str string
}

func main() {
  a := A{
    Ptr1: &B{"ptr-str-1"},
    Ptr2: &B{"ptr-str-2"},
    Val: B{"val-str"},
  }
  fmt.Println(a.Ptr1)
  fmt.Println(a.Ptr2)
  fmt.Println(a.Val)
  demo(a)
  fmt.Println(a.Ptr1)
  fmt.Println(a.Ptr2)
  fmt.Println(a.Val)
}

func demo(a A) {
  // Update a value of a pointer and changes will persist
  a.Ptr1.Str = "new-ptr-str1"
  // Use an entirely new B object and changes won't persist
  a.Ptr2 = &B{"new-ptr-str-2"}
  a.Val.Str = "new-val-str"
}

其实slice是类似一个上面结构的类型

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

上面的例子里面a作为值传递传给demo函数.demo函数持有的实际上是a的一份拷贝.修改这个拷贝里面的属性值是不会影响main里面的a的值,但是注意和slice类似,因为A是一个拥有一个指针属性的，虽然无法修改ptr1的值但是可以修改ptr1指针指向的地址的内容。所以ptr1 ptr2 中的地址还是没有变，但这个地址指向的内存中的内容被修改了。类似于slice里面pointer的值没有变,但是数组元素被修改了。