用new聲明slice時
1.new出來的分片變量逢防，只有一個地址，還沒有底層數(shù)組，如果直接賦值會panic详恼，這時候需要append來分片底層數(shù)組用make聲明時
1.當訪問分片超出當前分片大小的時候，會越界訪問 會panic坤溃，只能通過append方式增加分片容量訪問
2.append的時候拍霜，若超出底層數(shù)組大小，則會復制當前分片大小薪介，放到一個新數(shù)組里面擴容規(guī)則
1.擴容規(guī)則：1.舊容量 * 2 < 所需容量 => 新容量= 所需容量
否則走 2:舊長度< 1024 新容量 = 舊容量 * 2 ;舊長度 > 1024 擴四分之一擴容內存策略
1.所需內存 = 預估容量 * 元素類型大小
// runtime/slice.go
// et：表示slice的一個元素祠饺；old：表示舊的slice；cap：表示新切片需要的容量昭灵；
func growslice(et *_type, old slice, cap int) slice {
if cap < old.cap {
panic(errorString("growslice: cap out of range"))
}
if et.size == 0 {
// append should not create a slice with nil pointer but non-zero len.
// We assume that append doesn't need to preserve old.array in this case.
return slice{unsafe.Pointer(&zerobase), old.len, cap}
}
newcap := old.cap
// 兩倍擴容
doublecap := newcap + newcap
// 新切片需要的容量大于兩倍擴容的容量吠裆，則直接按照新切片需要的容量擴容
if cap > doublecap {
newcap = cap
} else {
// 原 slice 容量小于 1024 的時候，新 slice 容量按2倍擴容
if old.cap < 1024 {
newcap = doublecap
} else { // 原 slice 容量超過 1024烂完，新 slice 容量變成原來的1.25倍试疙。
// Check 0 < newcap to detect overflow
// and prevent an infinite loop.
for 0 < newcap && newcap < cap {
newcap += newcap / 4
}
// Set newcap to the requested cap when
// the newcap calculation overflowed.
if newcap <= 0 {
newcap = cap
}
}
}
// 后半部分還對 newcap 作了一個內存對齊，這個和內存分配策略相關抠蚣。進行內存對齊之后祝旷，新 slice 的容量是要 大于等于 老 slice 容量的 2倍或者1.25倍。
var overflow bool
var lenmem, newlenmem, capmem uintptr
// Specialize for common values of et.size.
// For 1 we don't need any division/multiplication.
// For sys.PtrSize, compiler will optimize division/multiplication into a shift by a constant.
// For powers of 2, use a variable shift.
switch {
case et.size == 1:
lenmem = uintptr(old.len)
newlenmem = uintptr(cap)
capmem = roundupsize(uintptr(newcap))
overflow = uintptr(newcap) > maxAlloc
newcap = int(capmem)
case et.size == sys.PtrSize:
lenmem = uintptr(old.len) * sys.PtrSize
newlenmem = uintptr(cap) * sys.PtrSize
capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
newcap = int(capmem / sys.PtrSize)
case isPowerOfTwo(et.size):
var shift uintptr
if sys.PtrSize == 8 {
// Mask shift for better code generation.
shift = uintptr(sys.Ctz64(uint64(et.size))) & 63
} else {
shift = uintptr(sys.Ctz32(uint32(et.size))) & 31
}
lenmem = uintptr(old.len) << shift
newlenmem = uintptr(cap) << shift
capmem = roundupsize(uintptr(newcap) << shift)
overflow = uintptr(newcap) > (maxAlloc >> shift)
newcap = int(capmem >> shift)
default:
lenmem = uintptr(old.len) * et.size
newlenmem = uintptr(cap) * et.size
capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
capmem = roundupsize(capmem)
newcap = int(capmem / et.size)
}
}
切片在擴容時會進行內存對齊嘶窄，這個和內存分配策略相關怀跛。進行內存對齊之后，新 slice 的容量是要 大于等于老 slice 容量的 2倍或者1.25倍柄冲，當原 slice 容量小于 1024 的時候吻谋，新 slice 容量變成原來的 2 倍；原 slice 容量超過 1024现横，新 slice 容量變成原來的1.25倍漓拾。
在 range 使用data[key] 方式來覆蓋原值
......略
for k,_ := range u{
n = append(n, &u[k])
}
append 在擴容超過當前slice指向的數(shù)組大小，才會新建并指向新數(shù)組底層復制原數(shù)組內容
