var slice = []int{1, 2, 3}
fmt.Println(slice, len(slice), cap(slice))
slice = append(slice, 4)
fmt.Println(slice, len(slice), cap(slice))

// growtslice 為切片分配新的存儲空間。
func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
   // oldLen 為舊的切片底層數(shù)組的長度
   oldLen := newLen - num
   // 分配的新的長度不能小于 0（整數(shù)溢出的時候會是負(fù)數(shù)）
   if newLen < 0 {
      panic(errorString("growslice: len out of range"))
   }
   // 如果結(jié)構(gòu)或數(shù)組類型不包含大小大于零的字段（或元素），則其大小為零。
   //（空數(shù)組、空結(jié)構(gòu)體，type b [0]int、type zero struct{}）
   // 兩個不同的零大小變量在內(nèi)存中可能具有相同的地址。
   if et.size == 0 {
      // append 不應(yīng)創(chuàng)建具有 nil 指針但長度非零的切片。
      // 在這種情況下，我們假設(shè) append 不需要保留 oldPtr。
      return slice{unsafe.Pointer(&zerobase), newLen, newLen}
   }
   // newcap 是新切片底層數(shù)組的容量
   newcap := oldCap
   // 兩倍容量
   doublecap := newcap + newcap
   if newLen > doublecap {
      // 如果追加元素之后，新的切片長度比舊切片 2 倍容量還大，
      // 則將新的切片的容量設(shè)置為跟長度一樣
      newcap = newLen
   } else {
      const threshold = 256
      if oldCap < threshold {
         // 舊的切片容量小于 256 的時候，
         // 進行兩倍擴容。
         newcap = doublecap
      } else {
         // oldCap >= 256
         // 檢查 0<newcap 以檢測溢出并防止無限循環(huán)。
         for 0 < newcap && newcap < newLen {
            // 從小切片的增長 2 倍過渡到大切片的增長 1.25 倍。
            newcap += (newcap + 3*threshold) / 4
         }
         // 當(dāng) newcap 計算溢出時，將 newcap 設(shè)置為請求的上限。
         if newcap <= 0 {
            newcap = newLen
         }
      }
   }
   // 計算實際所需要的內(nèi)存大小
   // 是否溢出
   var overflow bool
   // lenmem 表示舊的切片長度所需要的內(nèi)存大小
   //（lenmem 就是將舊切片數(shù)據(jù)復(fù)制到新切片的時候指定需要復(fù)制的內(nèi)存大小）
   // newlenmem 表示新的切片長度所需要的內(nèi)存大小
   // capmem 表示新的切片容量所需要的內(nèi)存大小
   var lenmem, newlenmem, capmem uintptr
   // 根據(jù) et.size 做一些計算上的優(yōu)化：
   // 對于 1，我們不需要任何除法/乘法。
   // 對于 goarch.PtrSize，編譯器會將除法/乘法優(yōu)化為移位一個常數(shù)。
   // 對于 2 的冪，使用可變移位。
   switch {
   case et.size == 1: // 比如 []byte，所需內(nèi)存大小 = size
      lenmem = uintptr(oldLen)
      newlenmem = uintptr(newLen)
      capmem = roundupsize(uintptr(newcap))
      overflow = uintptr(newcap) > maxAlloc
      newcap = int(capmem)
   case et.size == goarch.PtrSize: // 比如 []*int，所需內(nèi)存大小 = size * ptrSize
      lenmem = uintptr(oldLen) * goarch.PtrSize
      newlenmem = uintptr(newLen) * goarch.PtrSize
      capmem = roundupsize(uintptr(newcap) * goarch.PtrSize)
      overflow = uintptr(newcap) > maxAlloc/goarch.PtrSize
      newcap = int(capmem / goarch.PtrSize)
   case isPowerOfTwo(et.size): // 比如 []int64，所需內(nèi)存大小 = size << shift，也就是 size * 2^shift（2^shift 是 et.size）
      var shift uintptr
      if goarch.PtrSize == 8 {
         // Mask shift for better code generation.
         shift = uintptr(sys.TrailingZeros64(uint64(et.size))) & 63
      } else {
         shift = uintptr(sys.TrailingZeros32(uint32(et.size))) & 31
      }
      lenmem = uintptr(oldLen) << shift
      newlenmem = uintptr(newLen) << shift
      capmem = roundupsize(uintptr(newcap) << shift)
      overflow = uintptr(newcap) > (maxAlloc >> shift)
      newcap = int(capmem >> shift)
      capmem = uintptr(newcap) << shift
   default: // 沒得優(yōu)化，直接使用乘法了
      lenmem = uintptr(oldLen) * et.size
      newlenmem = uintptr(newLen) * et.size
      capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
      capmem = roundupsize(capmem)
      newcap = int(capmem / et.size)
      capmem = uintptr(newcap) * et.size
   }
   // 檢查是否溢出，以及是否超過最大可分配內(nèi)存
   if overflow || capmem > maxAlloc {
      panic(errorString("growslice: len out of range"))
   }
   // 分配實際所需要的內(nèi)存
   var p unsafe.Pointer
   if et.ptrdata == 0 { // 不包含指針
      // 分配 capmem 大小的內(nèi)存，不清零
      p = mallocgc(capmem, nil, false)
      // 這里只清空從 add(p, newlenmem) 開始大小為 capmem-newlenmem 的內(nèi)存，
      // 也就是前面的 newlenmem 長度不清空。
      // 因為最后的 capmem-newlenmem 這塊內(nèi)存，實際上是額外分配的容量。
      // 前面的那部分會被舊切片的數(shù)據(jù)以及新追加的數(shù)據(jù)覆蓋。
      memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
   } else {
      // 分配 capmem 大小的內(nèi)存，需要進行清零
      p = mallocgc(capmem, et, true)
      if lenmem > 0 && writeBarrier.enabled {
         // Only shade the pointers in oldPtr since we know the destination slice p
         // only contains nil pointers because it has been cleared during alloc.
         bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(oldPtr), lenmem-et.size+et.ptrdata)
      }
   }
   // 舊切片數(shù)據(jù)復(fù)制到新切片中，復(fù)制的內(nèi)容大小為 lenmem
   //（從 oldPtr 復(fù)制到 p）
   memmove(p, oldPtr, lenmem)
   return slice{p, newLen, newcap}
}