关于后端:Go-Slice-扩容的这些坑你踩过吗

前言

之前对 Go 语言 for 循环做了一次踩坑教训分享《Go for range 一不小心就掉坑里了》，大家直呼有用。

明天对切片 Slice 的 append 操作也做一次踩坑教训分享，心愿对敌人们有所帮忙，有用请三连反对。

常识重温

切片底层构造定义 ：蕴含 指向底层数组的指针 、 长度 和容量

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

append 操作：能够是 1 个、多个、甚至整个切片（记得前面加 …）；增加元素时当容量有余，则会主动触发切片扩容机制，产生切片正本，同时指向底层数组的指针发生变化

var nums []int
nums = append(nums, 1)
nums = append(nums, 2, 3, 4)
nums2 := []int{5, 6, 7}
nums = append(nums, nums2...)
fmt.Println(nums) //[1 2 3 4 5 6 7]

案例 1：传值 + 未扩容

先来看看上面会输入什么后果？

func main() {s1 := make([]int, 0, 5)
  fmt.Println("s1 切片:", s1)
  appendFunc(s1)
  fmt.Println("s1 切片:", s1)
  fmt.Println("s1 切片表达式:", s1[:5])
}

func appendFunc(s2 []int) {s2 = append(s2, 1, 2, 3)
  fmt.Println("s2 切片:", s2)
}

输入后果：

s1 切片:  []
s2 切片:  [1 2 3]
s1 切片:  []
s1 切片表达式:  [1 2 3 0 0]

看到这个后果，大家就会有疑难了，明明切片是援用类型，为什么 s2 append 了新元素后，s2 是有值了但 s1 却还是空的，并且对 s1 用切片表达式却能获取到值呢？

起因剖析前，咱们先来看看 s1 和 s2 到底是不是同一个切片，打印地址验证下

func main() {s1 := make([]int, 0, 5)
  fmt.Printf("s1 切片地址: %p\n", s1)
  appendFunc(s1)
  //...
}

func appendFunc(s2 []int) {s2 = append(s2, 1, 2, 3)
  fmt.Printf("s2 切片地址: %p\n", s2)
  //...
}

输入后果：s1 切片地址: 0xc000018150
s2 切片地址: 0xc000018150

看到这就得 傻眼了，两个切片的地址都是同一个，s2 批改后 s1 也应该同步批改，应该都有值啊

咱们还得持续再深究一下，fmt 包 %p打印的这个地址，到底是谁的地址

//fmt/print.go
func (p *pp) fmtPointer(value reflect.Value, verb rune) {
  var u uintptr
  switch value.Kind() {
  case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
    u = value.Pointer()
  default:
    p.badVerb(verb)
    return
  }
  //...
}

//reflect/value.go
func (v Value) Pointer() uintptr {k := v.kind()
  switch k {
  //...
  
  case Slice:
    return (*SliceHeader)(v.ptr).Data
  }
  panic(&ValueError{"reflect.Value.Pointer", v.kind()})
}

通过剖析 fmt 包的源码，不难发现，打印的地址，其实是切片里指向底层数组的指针存储的地址，并不是两个切片自身的地址。同时也阐明这两切片是指向同一个底层数组。

起因正式剖析：

1. 传值操作，s1 和 s2 是两个不同的切片变量，然而指向底层数组的指针是同一个；
2. 长度和容量的变动 ：s1 Len= 0 和 Cap=5，起初未产生过变动；s2 一开始被赋值时 Len= 0 和 Cap=5，在 append 操作后，Len= 3 和 Cap=5，同时底层数组值从[0,0,0,0,0] 被批改成了[1,2,3,0,0];
3. 输入后果 ，s1 因为 Len= 0 所以输入空[]，而 s1 用切片表达式，是基于底层数组[1,2,3,0,0] 进行切片，所以输入后果为[1,2,3,0,0]；

案例 2：传值 + 扩容

将案例 1，append 的元素个数超过切片容量，触发主动扩容，输入的后果又会是怎么的呢？

func main() {s1 := make([]int, 0, 5)
  fmt.Println("s1 切片:", s1)
  appendFunc(s1)
  fmt.Println("s1 切片:", s1)
  fmt.Println("s1 切片表达式:", s1[:5])
}

func appendFunc(s2 []int) {s2 = append(s2, 1, 2, 3, 4, 5, 6)
  fmt.Println("s2 切片:", s2)
}

输入后果：

s1 切片:  []
s2 切片:  [1 2 3 4 5 6]
s1 切片:  []
s1 切片表达式:  [0 0 0 0 0]

起因剖析：

1. 产生扩容后，s2 指向的底层数组会产生正本，导致 s1 和 s2 不再指向同一个底层数组；
2. 长度和容量的变动：s2 append 后 Len=6、Cap=10 和底层数组值为[1,2,3,4,5,6,0,0,0,0]；s2 的操作齐全不影响 s1 的数据，s1 依然是 Len=0、Cap= 5 和底层数组值为[0,0,0,0,0]；
3. 输入后果 ，s2 因为 Len= 6 所以输入[1,2,3,4,5,6]，s1 因为 Len= 0 所以输入空[]，而 s1 用切片表达式，是基于底层数组[0,0,0,0,0] 进行切片，所以输入后果为[0,0,0,0,0]；

案例 3：传址 + 不关怀扩容

下面两个传值操作的例子，不论扩容与否，都不会影响原切片 s1 的长度和容量。如果咱们 冀望批改 s2 的同时也批改原切片 s1，则须要用到切片指针，基于地址传递进行操作。

func main() {s1 := make([]int, 0, 5)
  fmt.Println("s1 切片:", s1)
  fmt.Printf("s1 切片地址: %p len:%d cap:%d\n", &s1, len(s1), cap(s1))
  appendFunc(&s1)
  fmt.Println("s1 切片:", s1)
  fmt.Println("s1 切片表达式:", s1[:5])
}

func appendFunc(s2 *[]int) {fmt.Printf("s2 切片地址: %p len:%d cap:%d\n", s2, len(*s2), cap(*s2))
  //*s2 = append(*s2, 1, 2, 3)
  *s2 = append(*s2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  fmt.Printf("append 后 s2 切片地址: %p len:%d cap:%d\n", s2, len(*s2), cap(*s2))
  fmt.Println("s2 切片:", *s2)
}

输入后果：

s1 切片:  []
s1 切片地址: 0xc00000c030 len:0 cap:5
s2 切片地址: 0xc00000c030 len:0 cap:5
append 后 s2 切片地址: 0xc00000c030 len:10 cap:10
s2 切片:  [1 2 3 4 5 6 7 8 9 10]
s1 切片:  [1 2 3 4 5 6 7 8 9 10]
s1 切片表达式:  [1 2 3 4 5]

万变不离其宗，传址操作，始终操作的是同一个切片变量，append 操作后，长度和容量都会同时发生变化，以及如果触发扩容，那么指向底层数组的指针，也都会同时发生变化。

总结

切片传值操作，append 未触发扩容，会同时批改底层数组的值，但不会影响原切片的长度和容量；当触发扩容，那么会产生正本，前面的批改则会和原底层数组剥来到，互不影响。

如果冀望在批改切片后，对原切片也产生批改，则能够应用 传址操作，始终基于同一个切片变量进行操作。

一起学习

须要简历优化和就业辅导的敌人能够私信我，也欢送关注我的公众号：

我的文章首发在我的公众号：程序员升职加薪之旅，欢送大家关注，第一工夫浏览我的文章。

也欢送大家关注我，点赞、留言、转发。你的反对，是我更文的最大能源！