• 用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 擴四分之一

• 擴容內(nèi)存策略
  1.所需內(nèi)存 = 預估容量 * 元素類型大小

// 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 作了一個內(nèi)存對齊，這個和內(nèi)存分配策略相關。進行內(nèi)存對齊之后，新 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)
 }
}

切片在擴容時會進行內(nèi)存對齊，這個和內(nèi)存分配策略相關。進行內(nèi)存對齊之后，新 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ù)組內(nèi)容