1. slice 扩容机制
如果 Slice 要扩容的容量大于 2 倍当前的容量，则直接按想要扩容的容量来 new 一个新的 Slice，否则继续判断当前的长度 len，如果 len 小于 1024，则直接按 2 倍容量来扩容，否则一直循环新增 1/4，直到大于想要扩容的容量
newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
newcap = cap
} else {
if old.len < 1024 {
newcap = doublecap
} else {
for newcap < cap {
newcap += newcap / 4
}
}
}
实际使用
// =========== 第一种
a := make([]string, 5)
fmt.Println(len(a), cap(a)) // 输出5 5
a = append(a, "aaa")
fmt.Println(len(a), cap(a)) // 输出6 10
// 总结： 由于make([]string, 5) 则默认会初始化5个 空的"", 因此后面 append 时，则需要2倍了
// =========== 第二种
a:=[]string{}
fmt.Println(len(a), cap(a)) // 输出0 0
a = append(a, "aaa")
fmt.Println(len(a), cap(a)) // 输出1 1
// 总结：由于[]string{}, 没有其他元素， 所以append 按 需要扩容的 cap 来
// =========== 第三种
a := make([]string, 0, 5)
fmt.Println(len(a), cap(a)) // 输出0 5
a = append(a, "aaa")
fmt.Println(len(a), cap(a)) // 输出1 5
// 总结：注意和第一种的区别，这里不会默认初始化5个，所以后面的append容量是够的，不用扩容
// =========== 第四种
b := make([]int, 1, 3)
a := []int{1, 2, 3}
copy(b, a)
fmt.Println(len(b)) // 输出1
// 总结：copy 取决于较短 slice 的 len, 一旦最小的len结束了，也就不再复制了
2.slice range 相关分析
下面代码段 是否陷入死循环？
v := []int{1, 2, 3}
for i := range v {
v = append(v, i)
}
上面代码的执行是不会一直循环下去的，原因在于 range 的时候会 copy 这个 slice 上的 len 属性到一个新的变量上，然后根据这个 copy 值去遍历 slice，因此遍历期间即使 slice 添加了元素，也不会改变这个变量的值了。
参考 range slice 源代码
// The loop we generate:
// for_temp := range
// len_temp := len(for_temp)
// for index_temp = 0; index_temp < len_temp; index_temp++ {
// value_temp = for_temp[index_temp]
// index = index_temp
// value = value_temp
// original body
// }
map range 的情况时如何？
m1 := make(map[string]string, 0)
m1["name"] = "jack"
for k, v := range m1 {
log.Println(k, v)
m1[fmt.Sprintf("%v_%v", k, 1)] = v
}
这段代码代码输出结果是不固定的，原因是 map实现是基于hash 表实现的，插入数据的位置是不固定的，遍历过程中不保证一定遍历到新插入的数据
map range 源码：
// var hiter map_iteration_struct
// for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
// index_temp = *hiter.key
// value_temp = *hiter.val
// index = index_temp
// value = value_temp
// original body
// }
3. 注意事项
range 一个 slice 的时候是进行一个值拷贝的，如果 slice 里存储的是指针集合，那在 遍历里修改是有效的，如果 slice 存储的是值类型的集合，那么就是在 copy 它们的副本，期间的修改也只是在修改这个副本，跟原来的 slice 里的元素是没有关系的
如果 slice 作为函数的入参，通常希望对 slice 的操作可以影响到底层数据，但是如果在函数内部 append 数据超过了 cap，导致重新分配底层数组，这时修改的 slice 将不再是原来入参的那个 slice 了。因此通常不建议在函数内部对 slice 有 append 操作，若有需要则显示的 return 这个 slice
func main() {
sl := make([]*M, 0, 0)
sl = append(sl, &M{
Name: "sun",
})
log.Println("sl 原始数据:", len(sl), cap(sl))
s2 := add(sl)
log.Println("sl 处理后数据：", len(sl), cap(sl))
log.Println("s2 处理后数据", len(s2), cap(s2))
for _, v := range s2 {
log.Println(v)
}
}
func add(m []*M) []*M {
m = append(m, &M{
Name: "wang1",
}, &M{
Name: "wang2",
})
return m
}
输出：
2022/02/17 15:43:46 sl 原始数据: 1 1
2022/02/17 15:43:46 sl 处理后数据： 1 1
2022/02/17 15:43:46 s2 处理后数据 3 3
2022/02/17 15:43:46 &{sun}
2022/02/17 15:43:46 &{wang1}
2022/02/17 15:43:46 &{wang2}
