扩容

slice 会迁移到新的内存位置，新底层数组的长度也会增加，这样就可以放置新增的元素。同时，为了应对未来可能再次发生的 append 操作，新的底层数组的长度，也就是新 slice 的容量是留了一定的 buffer 的。否则，每次添加元素的时候，都会发生迁移，成本太高。
新 slice 预留的 buffer 大小是有一定规律的。

1.18之前

当原 slice 容量小于 1024 的时候，新 slice 容量变成原来的 2 倍；原 slice 容量超过 1024，新 slice 容量变成原来的1.25倍。

func growslice(et *_type, old slice, cap int) slice {
    // ……
    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
                        }
                }
        }
        // ……
        
        capmem = roundupsize(uintptr(newcap) * ptrSize)
        newcap = int(capmem / ptrSize)
}

1.18之后

当原slice容量(oldcap)小于256的时候，新slice(newcap)容量为原来的2倍；原slice容量超过256，新slice容量newcap = oldcap+(oldcap+3*256)/4。

func growslice(et *_type, old slice, cap int) slice {
    // ……
    newcap := old.cap
        doublecap := newcap + newcap
        if cap > doublecap {
                newcap = cap
        } else {
            const threshold = 256
            if old.cap < threshold {
                    newcap = doublecap
            } else {
                for 0 < newcap && newcap < cap {
                    // Transition from growing 2x for small slices
                    // to growing 1.25x for large slices. This formula
                    // gives a smooth-ish transition between the two.
                    newcap += (newcap + 3*threshold) / 4
                }
                if newcap <= 0 {
                    newcap = cap
                }
            }
        }
        // ……
    
        capmem = roundupsize(uintptr(newcap) * ptrSize)
        newcap = int(capmem / ptrSize)
}

从小切片的2倍增长转变为大切片的1.25倍增长，这个公式在两者之间提供了一个平稳的过渡。
调整之后，随着切片容量的变大，增长比例逐渐向着1.25进行靠拢。slice扩容整体的增长曲线变得更加平滑。

扩容时除了扩容成指定大小之外，还做了内存对齐，进行内存对齐之后，新slice的容量 >= newcap。