Go语言学习七：slice

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}