基本呢就三个步骤，计算新的容量、分配新的数组、拷贝数据到新数组，社区很多人分享 slice 的增长方法，实际都不是很精确，因为大家只分析了计算 newcap 的那一段，也就是上面注释的第一部分，下面的 switch 根据 et.size 来调整 newcap 一段被直接忽略，社区的结论是："如果 selic 的容量小于1024个元素，那么扩容的时候 slice 的 cap 就翻番，乘以2；一旦元素个数超过1024个元素，增长因子就变成1.25，即每次增加原来容量的四分之一" 大多数情况也确实如此，但是根据 newcap 的计算规则，如果新的容量超过旧的容量2倍时会直接按新的容量分配，真的是这样吗?
package main import ( "fmt" ) func main() { s := make([]int, 10, 10) fmt.Println(len(s), cap(s)) s2 := make([]int, 40) s = append(s, s2...) fmt.Println(len(s), cap(s)) }以上代码的输出(Go Playground):
10 10
50 52
这个结果有点出人意料， 如果是2倍增长应该是 10 * 2 * 2 * 2 结果应该是80， 如果说新的容量高于旧容量的两倍但结果也不是50，实际上 newcap 的结果就是50，那段逻辑很好理解，但是switch 根据 et.size 来调整 newcap 后就是52了，这段逻辑走到了 case et.size == sys.PtrSize 这段，详细的以后做源码分析再说。
** 总结 **
当 slice 的长度超过其容量，会分配新的数组，并把旧数组上的值拷贝到新的数组
逐个元素添加到 slice 并操过其容量， 如果 selic 的容量小于1024个元素，那么扩容的时候 slice 的 cap 就翻番，乘以2；一旦元素个数超过1024个元素，增长因子就变成1.25，即每次增加原来容量的四分之一。
批量添加元素，当新的容量高于旧容量的两倍，就会分配比新容量稍大一些，并不会按上面第二条的规则扩容。
当 slice 发生扩容，引用新数组后，slice 操作不会再影响旧的数组，而是新的数组（社区经常讨论的传递 slice 容量超出后，修改数据不会作用到旧的数据上），所以往往设计函数如果会对长度调整都会返回新的 slice，例如 append 方法。
slice 是引用类型？slice 不发生扩容，所有的修改都会作用在原数组上，那如果把 slice 传递给一个函数或者赋值给另一个变量会发生什么呢，slice 是引用类型，会有新的内存被分配吗。
package main import ( "fmt" "strings" "unsafe" ) func main() { s := make([]int, 10, 20) size := unsafe.Sizeof(0) fmt.Printf("%p\n", &s) fmt.Printf("%x\n", *(*uintptr)(unsafe.Pointer(&s))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size*2))) slice(s) s1 := s fmt.Printf("%p\n", &s1) fmt.Printf("%x\n", *(*uintptr)(unsafe.Pointer(&s1))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s1)) + size))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s1)) + size*2))) fmt.Println(strings.Repeat("-", 50)) *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s1)) + size)) = 20 fmt.Printf("%x\n", *(*uintptr)(unsafe.Pointer(&s))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size*2))) fmt.Printf("%x\n", *(*uintptr)(unsafe.Pointer(&s1))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s1)) + size))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s1)) + size*2))) fmt.Println(s) fmt.Println(s1) fmt.Println(strings.Repeat("-", 50)) s2 := s s2 = append(s2, 1) fmt.Println(len(s), cap(s), s) fmt.Println(len(s1), cap(s1), s1) fmt.Println(len(s2), cap(s2), s2) } func slice(s []int) { size := unsafe.Sizeof(0) fmt.Printf("%p\n", &s) fmt.Printf("%x\n", *(*uintptr)(unsafe.Pointer(&s))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size))) fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + size*2))) }这个例子(Go Playground)比较长就不逐一分析了，在这个例子里面调用函数传递 slice 其变量的地址发生了变化， 但是引用数组的地址，slice 的长度和容量都没有变化， 这说明是对 slice 的浅拷贝，拷贝 slice 的三个属性创建一个新的变量，虽然引用底层数组还是一个，但是变量并不是一个。
第二个创建 s1 变量，使用 s 为其赋值，发现 s1 和函数调用一样也是 s 的浅拷贝，之后修改 s1 的长度发现 s1 的长度发生变化，但是 s 的长度保持不变， 这也说明 s1 就是 s 的浅拷贝。
这样设计有什么优势呢，第三步创建 s2 变量， 并且 append 一个元素， 发现 s2 的长度发生变化了， s 并没有，虽然这个数据就在底层数组上，但是用常规的方法 s 是看不到第11个位置上的数据的， s1 因为长度覆盖到第11个元素，所有能够看到这个数据的变化。这里能看到采用浅拷贝的方式可以使得切片的属性各自独立，而不会相互影响，这样可以有一定的隔离性，缺点也很明显，如果两个变量都引用同一个数组，同时 append， 在不发生扩容的情况下，总是最后一个 append 的结果被保留，可能引起一些编程上疑惑。
** 总结 **