var buffer [255]int
buffer := [255]int{0}

var slice []int // 直接聲明
slice := []int{1,2,3,4,5} // 字面量方式
slice := make([]int, 5, 10) // make創建
slice := array[1:5] // 截取下標的方式
slice := *new([]int) // new一個

func main()  {
 param1 := make([]int, 100)
 param2 := make([]int, 100000000)
 smallSlice(param1)
 largeSlice(param2)
}
func smallSlice(params []int)  {
 // ....
}
func largeSlice(params []int)  {
 // ....
}

type SliceHeader struct {
 Data uintptr
 Len  int
 Cap  int
}

slice := make([]int,5) // 0 0 0 0 0
slice := make([]*int,5) // nil nil nil nil nil

var slice []int
var slice = *new([]int)

var slice = []int{}
var slice = make([]int, 0)

// base address for all 0-byte allocations
var zerobase uintptr
// 分配對象內存
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 ...
 if size == 0 {
  return unsafe.Pointer(&zerobase)
 }
  ...
}

// 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)
 }
}

//1.18
newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
  newcap = cap
} else {
  const threshold = 256
  if old.cap < threshold {
    newcap = doublecap
  } else {
    // Check 0 < newcap to detect overflow
    // and prevent an infinite loop.
    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
    }
    // Set newcap to the requested cap when
    // the newcap calculation overflowed.
    if newcap <= 0 {
      newcap = cap
    }
  }
}

type SliceHeader struct {
 Data uintptr
 Len  int
 Cap  int
}

func modifySlice(s []string)  {
 s[0] = "song"
 s[1] = "Golang"
 fmt.Println("out slice: ", s)
}
func main()  {
 s := []string{"asong", "Golang夢工廠"}
 modifySlice(s)
 fmt.Println("inner slice: ", s)
}

func appendSlice(s []string)  {
 s = append(s, "快關注！！")
 fmt.Println("out slice: ", s)
}
func main()  {
 s := []string{"asong", "Golang夢工廠"}
 appendSlice(s)
 fmt.Println("inner slice: ", s)
}

for k,v := range _ { }
for k := range _ { }

s := []int{1, 2}
for k, v := range s {
}
會被編譯器認為是
for_temp := s
len_temp := len(for_temp)
for index_temp := 0; index_temp < len_temp; index_temp++ {
  value_temp := for_temp[index_temp]
  k := index_temp
  v := value_temp
}

package main
import (
 "fmt"
)
type user struct {
 name string
 age uint64
}
func main()  {
 u := []user{
  {"asong",23},
  {"song",19},
  {"asong2020",18},
 }
 for _,v := range u{
  if v.age != 18{
   v.age = 20
  }
 }
 fmt.Println(u)
}