切片是 Go 中的一種基本的數據結構，使用這種結構可以用來管理數據集合。切片的設計想法是由動態數組概念而來，為了開發者可以更加方便的使一個數據結構可以自動增加和減少。但是切片本身並不是動態數據或者數組指針。切片常見的操作有 reslice、append、copy。與此同時，切片還具有可索引，可疊代的優秀特性。

一. 切片和數組

關於切片和數組怎麼選擇？接下來好好討論討論這個問題。

在 Go 中，與 C 數組變量隱式作為指針使用不同，Go 數組是值類型，賦值和函數傳參操作都會複製整個數組數據。

func main() {
\tarrayA := [2]int{100, 200}
\tvar arrayB [2]int
\tarrayB = arrayA
\tfmt.Printf("arrayA : %p , %v\\n", &arrayA, arrayA)
\tfmt.Printf("arrayB : %p , %v\\n", &arrayB, arrayB)
\ttestArray(arrayA)
}
func testArray(x [2]int) {
\tfmt.Printf("func Array : %p , %v\\n", &x, x)
}

列印結果：

arrayA : 0xc4200bebf0 , [100 200]
arrayB : 0xc4200bec00 , [100 200]
func Array : 0xc4200bec30 , [100 200]

可以看到，三個內存地址都不同，這也就驗證了 Go 中數組賦值和函數傳參都是值複製的。那這會導致什麼問題呢？

假想每次傳參都用數組，那麼每次數組都要被複製一遍。如果數組大小有 100萬，在64位機器上就需要花費大約 800W 位元組，即 8MB 內存。這樣會消耗掉大量的內存。於是乎有人想到，函數傳參用數組的指針。

func main() {
\tarrayA := [2]int{100, 200}
\ttestArrayPoint(&arrayA) // 1.傳數組指針
\tarrayB := arrayA[:]
\ttestArrayPoint(&arrayB) // 2.傳切片
\tfmt.Printf("arrayA : %p , %v\\n", &arrayA, arrayA)
}
func testArrayPoint(x *[]int) {
\tfmt.Printf("func Array : %p , %v\\n", x, *x)
\t(*x)[1] += 100
}

列印結果：

func Array : 0xc4200b0140 , [100 200]
func Array : 0xc4200b0180 , [100 300]
arrayA : 0xc4200b0140 , [100 400]

這也就證明了數組指針確實到達了我們想要的效果。現在就算是傳入10億的數組，也只需要再棧上分配一個8個位元組的內存給指針就可以了。這樣更加高效的利用內存，性能也比之前的好。

不過傳指針會有一個弊端，從列印結果可以看到，第一行和第三行指針地址都是同一個，萬一原數組的指針指向更改了，那麼函數裡面的指針指向都會跟著更改。

切片的優勢也就表現出來了。用切片傳數組參數，既可以達到節約內存的目的，也可以達到合理處理好共享內存的問題。列印結果第二行就是切片，切片的指針和原來數組的指針是不同的。

由此我們可以得出結論：

把第一個大數組傳遞給函數會消耗很多內存，採用切片的方式傳參可以避免上述問題。切片是引用傳遞，所以它們不需要使用額外的內存並且比使用數組更有效率。

但是，依舊有反例。

package main
import "testing"
func array() [1024]int {
\tvar x [1024]int
\tfor i := 0; i < len(x); i++ {
\t\tx[i] = i
\t}
\treturn x
}
func slice() []int {
\tx := make([]int, 1024)
\tfor i := 0; i < len(x); i++ {
\t\tx[i] = i
\t}
\treturn x
}
func BenchmarkArray(b *testing.B) {
\tfor i := 0; i < b.N; i++ {
\t\tarray()
\t}
}
func BenchmarkSlice(b *testing.B) {
\tfor i := 0; i < b.N; i++ {
\t\tslice()
\t}
}

我們做一次性能測試，並且禁用內聯和優化，來觀察切片的堆上內存分配的情況。

 go test -bench . -benchmem -gcflags "-N -l"

輸出結果比較「令人意外」：

BenchmarkArray-4 500000 3637 ns/op 0 B/op 0 alloc s/op
BenchmarkSlice-4 300000 4055 ns/op 8192 B/op 1 alloc s/op

解釋一下上述結果，在測試 Array 的時候，用的是4核，循環次數是500000，平均每次執行時間是3637 ns，每次執行堆上分配內存總量是0，分配次數也是0 。

而切片的結果就「差」一點，同樣也是用的是4核，循環次數是300000，平均每次執行時間是4055 ns，但是每次執行一次，堆上分配內存總量是8192，分配次數也是1 。

這樣對比看來，並非所有時候都適合用切片代替數組，因為切片底層數組可能會在堆上分配內存，而且小數組在棧上拷貝的消耗也未必比 make 消耗大。

二. 切片的數據結構

切片本身並不是動態數組或者數組指針。它內部實現的數據結構通過指針引用底層數組，設定相關屬性將數據讀寫操作限定在指定的區域內。切片本身是一個只讀對象，其工作機制類似數組指針的一種封裝。

切片（slice）是對數組一個連續片段的引用，所以切片是一個引用類型（因此更類似於 C/C++ 中的數組類型，或者 Python 中的 list 類型）。這個片段可以是整個數組，或者是由起始和終止索引標識的一些項的子集。需要注意的是，終止索引標識的項不包括在切片內。切片提供了一個與指向數組的動態窗口。

給定項的切片索引可能比相關數組的相同元素的索引小。和數組不同的是，切片的長度可以在運行時修改，最小為 0 最大為相關數組的長度：切片是一個長度可變的數組。

Slice 的數據結構定義如下:

type slice struct {
\tarray unsafe.Pointer
\tlen int
\tcap int
}

切片的結構體由3部分構成，Pointer 是指向一個數組的指針，len 代表當前切片的長度，cap 是當前切片的容量。cap 總是大於等於 len 的。

如果想從 slice 中得到一塊內存地址，可以這樣做：

s := make([]byte, 200)
ptr := unsafe.Pointer(&s[0])

如果反過來呢？從 Go 的內存地址中構造一個 slice。

var ptr unsafe.Pointer
var s1 = struct {
 addr uintptr
 len int
 cap int
}{ptr, length, length}
s := *(*[]byte)(unsafe.Pointer(&s1))

構造一個虛擬的結構體，把 slice 的數據結構拼出來。

當然還有更加直接的方法，在 Go 的反射中就存在一個與之對應的數據結構 SliceHeader，我們可以用它來構造一個 slice

var o []byte
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&o)))
sliceHeader.Cap = length
sliceHeader.Len = length
sliceHeader.Data = uintptr(ptr)

三. 創建切片

make 函數允許在運行期動態指定數組長度，繞開了數組類型必須使用編譯期常量的限制。

創建切片有兩種形式，make 創建切片，空切片。

1. make 和切片字面量

func makeslice(et *_type, len, cap int) slice {
\t// 根據切片的數據類型，獲取切片的最大容量
\tmaxElements := maxSliceCap(et.size)
 // 比較切片的長度，長度值域應該在[0,maxElements]之間
\tif len < 0 || uintptr(len) > maxElements {
\t\tpanic(errorString("makeslice: len out of range"))
\t}
 // 比較切片的容量，容量值域應該在[len,maxElements]之間
\tif cap < len || uintptr(cap) > maxElements {
\t\tpanic(errorString("makeslice: cap out of range"))
\t}
 // 根據切片的容量申請內存
\tp := mallocgc(et.size*uintptr(cap), et, true)
 // 返回申請好內存的切片的首地址
\treturn slice{p, len, cap}
}

還有一個 int64 的版本：

func makeslice64(et *_type, len64, cap64 int64) slice {
\tlen := int(len64)
\tif int64(len) != len64 {
\t\tpanic(errorString("makeslice: len out of range"))
\t}
\tcap := int(cap64)
\tif int64(cap) != cap64 {
\t\tpanic(errorString("makeslice: cap out of range"))
\t}
\treturn makeslice(et, len, cap)
}

實現原理和上面的是一樣的，只不過多了把 int64 轉換成 int 這一步罷了。

上圖是用 make 函數創建的一個 len = 4， cap = 6 的切片。內存空間申請了6個 int 類型的內存大小。由於 len = 4，所以後面2個暫時訪問不到，但是容量還是在的。這時候數組裡面每個變量都是0 。

除了 make 函數可以創建切片以外，字面量也可以創建切片。

這裡是用字面量創建的一個 len = 6，cap = 6 的切片，這時候數組裡面每個元素的值都初始化完成了。需要注意的是 [ ] 裡面不要寫數組的容量，因為如果寫了個數以後就是數組了，而不是切片了。

還有一種簡單的字面量創建切片的方法。如上圖。上圖就 Slice A 創建出了一個 len = 3，cap = 3 的切片。從原數組的第二位元素(0是第一位)開始切，一直切到第四位為止(不包括第五位)。同理，Slice B 創建出了一個 len = 2，cap = 4 的切片。

2. nil 和空切片

nil 切片和空切片也是常用的。

var slice []int

nil 切片被用在很多標準庫和內置函數中，描述一個不存在的切片的時候，就需要用到 nil 切片。比如函數在發生異常的時候，返回的切片就是 nil 切片。nil 切片的指針指向 nil。

空切片一般會用來表示一個空的集合。比如資料庫查詢，一條結果也沒有查到，那麼就可以返回一個空切片。

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

空切片和 nil 切片的區別在於，空切片指向的地址不是nil，指向的是一個內存地址，但是它沒有分配任何內存空間，即底層元素包含0個元素。

最後需要說明的一點是。不管是使用 nil 切片還是空切片，對其調用內置函數 append，len 和 cap 的效果都是一樣的。

四. 切片擴容

當一個切片的容量滿了，就需要擴容了。怎麼擴，策略是什麼？

func growslice(et *_type, old slice, cap int) slice {
\tif raceenabled {
\t\tcallerpc := getcallerpc(unsafe.Pointer(&et))
\t\tracereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
\t}
\tif msanenabled {
\t\tmsanread(old.array, uintptr(old.len*int(et.size)))
\t}
\tif et.size == 0 {
\t\t// 如果新要擴容的容量比原來的容量還要小，這代表要縮容了，那麼可以直接報panic了。
\t\tif cap < old.cap {
\t\t\tpanic(errorString("growslice: cap out of range"))
\t\t}
\t\t// 如果當前切片的大小為0，還調用了擴容方法，那麼就新生成一個新的容量的切片返回。
\t\treturn slice{unsafe.Pointer(&zerobase), old.len, cap}
\t}
 // 這裡就是擴容的策略
\tnewcap := old.cap
\tdoublecap := newcap + newcap
\tif cap > doublecap {
\t\tnewcap = cap
\t} else {
\t\tif old.len < 1024 {
\t\t\tnewcap = doublecap
\t\t} else {
\t\t\t// Check 0 < newcap to detect overflow
\t\t\t// and prevent an infinite loop.
\t\t\tfor 0 < newcap && newcap < cap {
\t\t\t\tnewcap += newcap / 4
\t\t\t}
\t\t\t// Set newcap to the requested cap when
\t\t\t// the newcap calculation overflowed.
\t\t\tif newcap <= 0 {
\t\t\t\tnewcap = cap
\t\t\t}
\t\t}
\t}
\t// 計算新的切片的容量，長度。
\tvar lenmem, newlenmem, capmem uintptr
\tconst ptrSize = unsafe.Sizeof((*byte)(nil))
\tswitch et.size {
\tcase 1:
\t\tlenmem = uintptr(old.len)
\t\tnewlenmem = uintptr(cap)
\t\tcapmem = roundupsize(uintptr(newcap))
\t\tnewcap = int(capmem)
\tcase ptrSize:
\t\tlenmem = uintptr(old.len) * ptrSize
\t\tnewlenmem = uintptr(cap) * ptrSize
\t\tcapmem = roundupsize(uintptr(newcap) * ptrSize)
\t\tnewcap = int(capmem / ptrSize)
\tdefault:
\t\tlenmem = uintptr(old.len) * et.size
\t\tnewlenmem = uintptr(cap) * et.size
\t\tcapmem = roundupsize(uintptr(newcap) * et.size)
\t\tnewcap = int(capmem / et.size)
\t}
\t// 判斷非法的值，保證容量是在增加，並且容量不超過最大容量
\tif cap < old.cap || uintptr(newcap) > maxSliceCap(et.size) {
\t\tpanic(errorString("growslice: cap out of range"))
\t}
\tvar p unsafe.Pointer
\tif et.kind&kindNoPointers != 0 {
\t\t// 在老的切片後面繼續擴充容量
\t\tp = mallocgc(capmem, nil, false)
\t\t// 將 lenmem 這個多個 bytes 從 old.array地址 拷貝到 p 的地址處
\t\tmemmove(p, old.array, lenmem)
\t\t// 先將 P 地址加上新的容量得到新切片容量的地址，然後將新切片容量地址後面的 capmem-newlenmem 個 bytes 這塊內存初始化。為之後繼續 append() 操作騰出空間。
\t\tmemclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
\t} else {
\t\t// 重新申請新的數組給新切片
\t\t// 重新申請 capmen 這個大的內存地址，並且初始化為0值
\t\tp = mallocgc(capmem, et, true)
\t\tif !writeBarrier.enabled {
\t\t\t// 如果還不能打開寫鎖，那麼只能把 lenmem 大小的 bytes 位元組從 old.array 拷貝到 p 的地址處
\t\t\tmemmove(p, old.array, lenmem)
\t\t} else {
\t\t\t// 循環拷貝老的切片的值
\t\t\tfor i := uintptr(0); i < lenmem; i += et.size {
\t\t\t\ttypedmemmove(et, add(p, i), add(old.array, i))
\t\t\t}
\t\t}
\t}
\t// 返回最終新切片，容量更新為最新擴容之後的容量
\treturn slice{p, old.len, newcap}
}

上述就是擴容的實現。主要需要關注的有兩點，一個是擴容時候的策略，還有一個就是擴容是生成全新的內存地址還是在原來的地址後追加。

1. 擴容策略

先看看擴容策略。

func main() {
\tslice := []int{10, 20, 30, 40}
\tnewSlice := append(slice, 50)
\tfmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\\n", slice, &slice, len(slice), cap(slice))
\tfmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
\tnewSlice[1] += 10
\tfmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\\n", slice, &slice, len(slice), cap(slice))
\tfmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
}

輸出結果：

Before slice = [10 20 30 40], Pointer = 0xc4200b0140, len = 4, cap = 4
Before newSlice = [10 20 30 40 50], Pointer = 0xc4200b0180, len = 5, cap = 8
After slice = [10 20 30 40], Pointer = 0xc4200b0140, len = 4, cap = 4
After newSlice = [10 30 30 40 50], Pointer = 0xc4200b0180, len = 5, cap = 8

用圖表示出上述過程。

從圖上我們可以很容易的看出，新的切片和之前的切片已經不同了，因為新的切片更改了一個值，並沒有影響到原來的數組，新切片指向的數組是一個全新的數組。並且 cap 容量也發生了變化。這之間究竟發生了什麼呢？

Go 中切片擴容的策略是這樣的：

• 首先判斷，如果新申請容量（cap）大於2倍的舊容量（old.cap），最終容量（newcap）就是新申請的容量（cap）
• 否則判斷，如果舊切片的長度小於1024，則最終容量(newcap)就是舊容量(old.cap)的兩倍，即（newcap=doublecap）
• 否則判斷，如果舊切片長度大於等於1024，則最終容量（newcap）從舊容量（old.cap）開始循環增加原來的 1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最終容量（newcap）大於等於新申請的容量(cap)，即（newcap >= cap）
• 如果最終容量（cap）計算值溢出，則最終容量（cap）就是新申請容量（cap）

如果切片的容量小於 1024 個元素，於是擴容的時候就翻倍增加容量。上面那個例子也驗證了這一情況，總容量從原來的4個翻倍到現在的8個。

一旦元素個數超過 1024 個元素，那麼增長因子就變成 1.25 ，即每次增加原來容量的四分之一。

注意：擴容擴大的容量都是針對原來的容量而言的，而不是針對原來數組的長度而言的。

2. 新數組 or 老數組 ？

再談談擴容之後的數組一定是新的麼？這個不一定，分兩種情況。

情況一：

func main() {
\tarray := [4]int{10, 20, 30, 40}
\tslice := array[0:2]
\tnewSlice := append(slice, 50)
\tfmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\\n", slice, &slice, len(slice), cap(slice))
\tfmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
\tnewSlice[1] += 10
\tfmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\\n", slice, &slice, len(slice), cap(slice))
\tfmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
\tfmt.Printf("After array = %v\\n", array)
}

列印輸出：

Before slice = [10 20], Pointer = 0xc4200c0040, len = 2, cap = 4
Before newSlice = [10 20 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After slice = [10 30], Pointer = 0xc4200c0040, len = 2, cap = 4
After newSlice = [10 30 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After array = [10 30 50 40]

把上述過程用圖表示出來，如下圖。

通過列印的結果，我們可以看到，在這種情況下，擴容以後並沒有新建一個新的數組，擴容前後的數組都是同一個，這也就導致了新的切片修改了一個值，也影響到了老的切片了。並且 append() 操作也改變了原來數組裡面的值。一個 append() 操作影響了這麼多地方，如果原數組上有多個切片，那麼這些切片都會被影響！無意間就產生了莫名的 bug！

這種情況，由於原數組還有容量可以擴容，所以執行 append() 操作以後，會在原數組上直接操作，所以這種情況下，擴容以後的數組還是指向原來的數組。

這種情況也極容易出現在字面量創建切片時候，第三個參數 cap 傳值的時候，如果用字面量創建切片，cap 並不等於指向數組的總容量，那麼這種情況就會發生。

slice := array[1:2:3]

上面這種情況非常危險，極度容易產生 bug 。

建議用字面量創建切片的時候，cap 的值一定要保持清醒，避免共享原數組導致的 bug。

情況二：

情況二其實就是在擴容策略裡面舉的例子，在那個例子中之所以生成了新的切片，是因為原來數組的容量已經達到了最大值，再想擴容， Go 默認會先開一片內存區域，把原來的值拷貝過來，然後再執行 append() 操作。這種情況絲毫不影響原數組。

所以建議儘量避免情況一，儘量使用情況二，避免 bug 產生。

五. 切片拷貝

Slice 中拷貝方法有2個。

func slicecopy(to, fm slice, width uintptr) int {
\t// 如果源切片或者目標切片有一個長度為0，那麼就不需要拷貝，直接 return 
\tif fm.len == 0 || to.len == 0 {
\t\treturn 0
\t}
\t// n 記錄下源切片或者目標切片較短的那一個的長度
\tn := fm.len
\tif to.len < n {
\t\tn = to.len
\t}
\t// 如果入參 width = 0，也不需要拷貝了，返回較短的切片的長度
\tif width == 0 {
\t\treturn n
\t}
\t// 如果開啟了競爭檢測
\tif raceenabled {
\t\tcallerpc := getcallerpc(unsafe.Pointer(&to))
\t\tpc := funcPC(slicecopy)
\t\tracewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
\t\tracereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
\t}
\t// 如果開啟了 The memory sanitizer (msan)
\tif msanenabled {
\t\tmsanwrite(to.array, uintptr(n*int(width)))
\t\tmsanread(fm.array, uintptr(n*int(width)))
\t}
\tsize := uintptr(n) * width
\tif size == 1 { 
\t\t// TODO: is this still worth it with new memmove impl?
\t\t// 如果只有一個元素，那麼指針直接轉換即可
\t\t*(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
\t} else {
\t\t// 如果不止一個元素，那麼就把 size 個 bytes 從 fm.array 地址開始，拷貝到 to.array 地址之後
\t\tmemmove(to.array, fm.array, size)
\t}
\treturn n
}

在這個方法中，slicecopy 方法會把源切片值(即 fm Slice )中的元素複製到目標切片(即 to Slice )中，並返回被複製的元素個數，copy 的兩個類型必須一致。slicecopy 方法最終的複製結果取決於較短的那個切片，當較短的切片複製完成，整個複製過程就全部完成了。

舉個例子，比如：

func main() {
\tarray := []int{10, 20, 30, 40}
\tslice := make([]int, 6)
\tn := copy(slice, array)
\tfmt.Println(n,slice)
}

還有一個拷貝的方法，這個方法原理和 slicecopy 方法類似，不在贅述了，注釋寫在代碼裡面了。

func slicestringcopy(to []byte, fm string) int {
\t// 如果源切片或者目標切片有一個長度為0，那麼就不需要拷貝，直接 return 
\tif len(fm) == 0 || len(to) == 0 {
\t\treturn 0
\t}
\t// n 記錄下源切片或者目標切片較短的那一個的長度
\tn := len(fm)
\tif len(to) < n {
\t\tn = len(to)
\t}
\t// 如果開啟了競爭檢測
\tif raceenabled {
\t\tcallerpc := getcallerpc(unsafe.Pointer(&to))
\t\tpc := funcPC(slicestringcopy)
\t\tracewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
\t}
\t// 如果開啟了 The memory sanitizer (msan)
\tif msanenabled {
\t\tmsanwrite(unsafe.Pointer(&to[0]), uintptr(n))
\t}
\t// 拷貝字符串至位元組數組
\tmemmove(unsafe.Pointer(&to[0]), stringStructOf(&fm).str, uintptr(n))
\treturn n
}

再舉個例子，比如：

func main() {
\tslice := make([]byte, 3)
\tn := copy(slice, "abcdef")
\tfmt.Println(n,slice)
}

輸出：

3 [97,98,99]

說到拷貝，切片中有一個需要注意的問題。

func main() {
\tslice := []int{10, 20, 30, 40}
\tfor index, value := range slice {
\t\tfmt.Printf("value = %d , value-addr = %x , slice-addr = %x\\n", value, &value, &slice[index])
\t}
}

輸出：

value = 10 , value-addr = c4200aedf8 , slice-addr = c4200b0320

value = 20 , value-addr = c4200aedf8 , slice-addr = c4200b0328

value = 30 , value-addr = c4200aedf8 , slice-addr = c4200b0330

value = 40 , value-addr = c4200aedf8 , slice-addr = c4200b0338

從上面結果我們可以看到，如果用 range 的方式去遍歷一個切片，拿到的 Value 其實是切片裡面的值拷貝。所以每次列印 Value 的地址都不變。

由於 Value 是值拷貝的，並非引用傳遞，所以直接改 Value 是達不到更改原切片值的目的的，需要通過 &slice[index] 獲取真實的地址。

Reference：

《Go in action》

《Go 語言學習筆記》

GitHub Repo：Halfrost-Field

Follow: halfrost · GitHub

Source: https://halfrost.com/go_slice/