type slice struct {
	array unsafe.Pointer // 數(shù)組指針
	len   int  //切片長(zhǎng)度
	cap   int // 切片容量
}

var vocabList []uint64

package main
func main() {
	var vocabList []uint64
	println(vocabList == nil)
}
// output:
// true

var vocabList = *new([]uint64)

var vocabList = []uint64{1,2,3,4}

var vocabList = make([]uint64,10)

func main() {
	var vocabList = make([]uint64,10)
	fmt.Printf("slice:%v,len:%d,cap:%d",vocabList,len(vocabList),cap(vocabList))
}
// output:
// slice:[0 0 0 0 0 0 0 0 0 0],len:10,cap:10

var vocabList = resList[3:5]

var vocabList []int
vocabList == nil //true

vocabList := make([]int,0)
vocabList == nil // false
vocabList1 = []int{}
vocabList1 == nil //false

package main
type Word struct {
	SenseIds []int
}
func main() {
	word := Word{}
	println(word.SenseIds == nil) //true
	word1 := Word{
		SenseIds: make([]int,0),
	}
	println(word1.SenseIds == nil) //false
}

package main
import "encoding/json"
type Word struct {
	SenseIds []int `json:"sense_ids" `
}
func main() {
	word := Word{}
	marshal, err := json.Marshal(word)
	if err != nil {
		return
	}
	println(string(marshal)) //{"sense_ids":null}
	word1 := Word{
		SenseIds: []int{},
	}
	marshal1, err := json.Marshal(word1)
	if err != nil {
		return
	}
	println(string(marshal1)) //{"sense_ids":[]}
}

bSlice := aSlice[start:stop:capacityIndex]
// satrt <= stop <= capacityIndex
//capacityIndex不是必須的，默認(rèn)=原來(lái)切片的cap-startIndex
// 如果指定 新切片的容量為 capacityIndex-start

package main
import (
	"fmt"
)
func main() {
	slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := slice[2:5]  
	fmt.Println("============= 1 ==============")
	fmt.Printf("%v len:%d  cap:%d \n",slice,len(slice),cap(slice))
	fmt.Printf("%v len:%d  cap:%d \n",s1,len(s1),cap(s1))
	s2 := s1[2:6:7]
	fmt.Println("============= 2 ==============")
	fmt.Printf("%v len:%d  cap:%d \n",slice,len(slice),cap(slice))
	fmt.Printf("%v len:%d  cap:%d \n",s1,len(s1),cap(s1))
	fmt.Printf("%v len:%d  cap:%d \n",s2,len(s2),cap(s2))
    // 到這里是正確的切片操作，slice，s1，s2通用底層數(shù)組
	s2 = append(s2, 100) //s2追加100，此時(shí)s2中l(wèi)en=cap，還沒(méi)有觸發(fā)擴(kuò)容操作
	fmt.Println("============= 3 ==============")
	fmt.Printf("%v len:%d  cap:%d \n",slice,len(slice),cap(slice))
	fmt.Printf("%v len:%d  cap:%d \n",s1,len(s1),cap(s1))
	fmt.Printf("%v len:%d  cap:%d \n",s2,len(s2),cap(s2))
	s2 = append(s2, 200)// 200加不進(jìn)去了，觸發(fā)擴(kuò)容操作，此時(shí)s2的底層數(shù)組和s1，slice不一樣了
	fmt.Println("============= 3 ==============")
	fmt.Printf("%v len:%d  cap:%d \n",slice,len(slice),cap(slice))
	fmt.Printf("%v len:%d  cap:%d \n",s1,len(s1),cap(s1))
	fmt.Printf("%v len:%d  cap:%d \n",s2,len(s2),cap(s2))
	s1[2] = 20 // s1和slice底層數(shù)組還是一樣的
	fmt.Println("============= 3 ==============")
	fmt.Printf("%v len:%d  cap:%d \n",slice,len(slice),cap(slice))
	fmt.Printf("%v len:%d  cap:%d \n",s1,len(s1),cap(s1))
	fmt.Printf("%v len:%d  cap:%d \n",s2,len(s2),cap(s2))
}
輸出如下：
============= 1 ==============
[0 1 2 3 4 5 6 7 8 9] len:10  cap:10 
[2 3 4] len:3  cap:8 
============= 2 ==============
[0 1 2 3 4 5 6 7 8 9] len:10  cap:10 
[2 3 4] len:3  cap:8 
[4 5 6 7] len:4  cap:5 
============= 3 ==============
[0 1 2 3 4 5 6 7 100 9] len:10  cap:10 
[2 3 4] len:3  cap:8 
[4 5 6 7 100] len:5  cap:5 
============= 3 ==============
[0 1 2 3 4 5 6 7 100 9] len:10  cap:10 
[2 3 4] len:3  cap:8 
[4 5 6 7 100 200] len:6  cap:10 
============= 3 ==============
[0 1 2 3 20 5 6 7 100 9] len:10  cap:10 
[2 3 20] len:3  cap:8 
[4 5 6 7 100 200] len:6  cap:10 

package main
import (
	"fmt"
	"unsafe"
)
func main() {
	ints := make([]int, 0) // 創(chuàng)建了一個(gè)長(zhǎng)度為0的切片
	i := *(*[3]int)(unsafe.Pointer(&ints)) // 利用Pointer將slice轉(zhuǎn)換為長(zhǎng)度為3的int數(shù)組，此操作可以查看slice結(jié)構(gòu)體中各個(gè)字段的數(shù)值
	fmt.Printf("slice1:%v \n",i)
	fmt.Printf("slice:%v \n",ints)
	var ints1 = append(ints, 1) // 追加一個(gè)元素
	i2 := *(*[3]int)(unsafe.Pointer(&ints1))
	fmt.Printf("slice2 %v \n",i2)   // slice對(duì)應(yīng)的底層數(shù)組發(fā)生了擴(kuò)容操作，底層數(shù)組已經(jīng)變了
	fmt.Printf("slice2:%v \n",ints)
}

// 函數(shù)入?yún)⒄f(shuō)明如下
//1. et 類型
//2. old 老切片
//3. cap 需要分配的指定容量，為了方便期間，調(diào)用這個(gè)函數(shù)的時(shí)候cap傳遞的都是老的slice的cap
func growslice(et *_type, old slice, cap int) slice { 
	if raceenabled { // 是否啟動(dòng)競(jìng)爭(zhēng)檢測(cè)
		callerpc := getcallerpc()
		racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, abi.FuncPCABIInternal(growslice))
	}
	if msanenabled { //內(nèi)存檢查，確保沒(méi)有未初始化的內(nèi)存被使用
		msanread(old.array, uintptr(old.len*int(et.size)))
	}
	if asanenabled { // 檢查內(nèi)存訪問(wèn)是否越界
		asanread(old.array, uintptr(old.len*int(et.size)))
	}
	if cap < old.cap {
		panic(errorString("growslice: cap out of range"))
	}
	if et.size == 0 {
	    // 正常是不會(huì)這樣的，但為了安全還是處理了0的情況
		return slice{unsafe.Pointer(&zerobase), old.len, cap}
	}
	// 開(kāi)始計(jì)算新的cap
	newcap := old.cap
	doublecap := newcap + newcap // 2倍
	if cap > doublecap { // 新的cap要是老的2倍
		newcap = cap
	} else {
		const threshold = 256
		if old.cap < threshold { // cap小于256，newCap為oldCap的兩倍
			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.
				// 這個(gè)公式可以當(dāng)超過(guò)256之后i，可以實(shí)現(xiàn)1.25到2倍的平滑過(guò)渡
				newcap += (newcap + 3*threshold) / 4  // 這個(gè)公式化簡(jiǎn)一下 newCap = oldCap*1.25 + 192（3/4*256）
			}
			// Set newcap to the requested cap when
			// the newcap calculation overflowed.
			if newcap <= 0 { // 防止溢出
				newcap = cap
			}
		}
	}
    // 下面的邏輯是對(duì)上面計(jì)算出來(lái)的newCap來(lái)做對(duì)齊操作，上面的計(jì)算不是真正的結(jié)果，下面還需要做內(nèi)存對(duì)齊操作。
	var overflow bool
	var lenmem, newlenmem, capmem uintptr
	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 == goarch.PtrSize:
		lenmem = uintptr(old.len) * goarch.PtrSize
		newlenmem = uintptr(cap) * goarch.PtrSize
		capmem = roundupsize(uintptr(newcap) * goarch.PtrSize)
		overflow = uintptr(newcap) > maxAlloc/goarch.PtrSize
		newcap = int(capmem / goarch.PtrSize)
	case isPowerOfTwo(et.size):
		var shift uintptr
		if goarch.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)
	}
	// The check of overflow in addition to capmem > maxAlloc is needed
	// to prevent an overflow which can be used to trigger a segfault
	// on 32bit architectures with this example program:
	//
	// type T [1<<27 + 1]int64
	//
	// var d T
	// var s []T
	//
	// func main() {
	//   s = append(s, d, d, d, d)
	//   print(len(s), "\n")
	// }
	if overflow || capmem > maxAlloc {
		panic(errorString("growslice: cap out of range"))
	}
	var p unsafe.Pointer
    // 下面是分配新的數(shù)組
	if et.ptrdata == 0 { // 原slice底層數(shù)組為0，也就是nil切片，
		p = mallocgc(capmem, nil, false)
		// The append() that calls growslice is going to overwrite from old.len to cap (which will be the new length).
		// Only clear the part that will not be overwritten.
		memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem) // 然后使用memclrNoHeapPointers函數(shù)來(lái)清除新分配的內(nèi)存
	} else {
		// Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
		p = mallocgc(capmem, et, true) // 分配新的底層數(shù)組
		if lenmem > 0 && writeBarrier.enabled { // 之前有數(shù)據(jù)，并且寫屏障已經(jīng)開(kāi)啟
			// Only shade the pointers in old.array since we know the destination slice p
			// only contains nil pointers because it has been cleared during alloc.
			bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem-et.size+et.ptrdata)
		}
	}
	// copy元素
	memmove(p, old.array, lenmem)
   // 創(chuàng)建新的切片返回
	return slice{p, old.len, newcap}
}

package main
import "fmt"
func main() {
	var s = []int{}
	oldCap := cap(s)
	for i := 0; i < 2048; i++ {
		s = append(s, i)
		newCap := cap(s)
		if newCap != oldCap {
			// 追加元素，當(dāng)容量發(fā)生變化的時(shí)候，打印，擴(kuò)容之前的元素，cap，導(dǎo)致擴(kuò)容的元素，和擴(kuò)容之后的cap
			fmt.Printf("[%d -> %4d] cap = %-4d    after append %-4d  cap = %-4d\n", 0, i-1, oldCap, i, newCap)
			oldCap = newCap
		}
	}
}
// outPut
[0 ->   -1] cap = 0     |  after append 0     cap = 1   
[0 ->    0] cap = 1     |  after append 1     cap = 2   
[0 ->    1] cap = 2     |  after append 2     cap = 4   
[0 ->    3] cap = 4     |  after append 4     cap = 8   
[0 ->    7] cap = 8     |  after append 8     cap = 16  
[0 ->   15] cap = 16    |  after append 16    cap = 32  
[0 ->   31] cap = 32    |  after append 32    cap = 64  
[0 ->   63] cap = 64    |  after append 64    cap = 128 
[0 ->  127] cap = 128   |  after append 128   cap = 256    // 256之前都是2倍
[0 ->  255] cap = 256   |  after append 256   cap = 512    // 1.25 * 256 + 192 = 512
[0 ->  511] cap = 512   |  after append 512   cap = 848    // 1.25 * 512 + 192 = 832
[0 ->  847] cap = 848   |  after append 848   cap = 1280
[0 -> 1279] cap = 1280  |  after append 1280  cap = 1792
[0 -> 1791] cap = 1792  |  after append 1792  cap = 2560

func main() {
	var vocabs = []int{1,2,3,4,5,6,7,8,9}
	// 現(xiàn)在將5去除掉，將5之后的移動(dòng)到前面 
	copy(vocabs[4:],vocabs[5:])
	fmt.Printf("%v",vocabs)
}
//outPut
[1 2 3 4 6 7 8 9 9]

func main() {
	ints := make([]int, 10)
	i1 := make([]int,0, 5)
	for i := 0; i < 5; i++ {
		i1 = append(i1, i)
	}
	i2 := make([]int,0, 5)
	for i := 5; i < 10; i++ {
		i2 = append(i2, i)
	}
	copy(ints,i1) // 從i1全部復(fù)制到ints中
	copy(ints[len(i1):],i2) // 將i2復(fù)制到ints的len（i1）位置開(kāi)始一直到結(jié)束的數(shù)組中
	fmt.Printf("%v\n",i1)
	fmt.Printf("%v\n",i2)
	fmt.Printf("%v\n",ints)
}
// output
[0 1 2 3 4]
[5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

package main
import "fmt"
func main() {
	ints := make([]int, 3)
	i1 := make([]int,0, 10)
	for i := 0; i < 10; i++ {
		i1 = append(i1, i)
	}
	copy(ints,i1)
	fmt.Printf("%v",ints)
}
//outPut:
[0 1 2]