出品 | 滴滴技術
作者 | 饒成全
前言：Go 語言的 slice 很好用，不過也有一些坑。slice 是 Go 語言一個很重要的數據結構。網上已經有很多文章寫過了，似乎沒必要再寫。但是每個人看問題的視角不同，寫出來的東西自然也不一樣。我這篇會從更底層的彙編語言去解讀它。而且在我寫這篇文章的過程中，發現絕大部分文章都存在一些問題，文章裏會講到，這裏先不展開。
希望以後有人想和你討論 slice，本篇文章能夠對你有所幫助。
▎閱讀索引
1.關於 slice
2.slice 的創建
- 直接聲明
- 字面量
- make
- 截取
3.slice 和數組的區別
4.append 到底做了什麼
5.爲什麼 nil slice 可以直接 append
6.傳 slice 和 slice 指針有什麼區別
7.總結
8.參考資料
▎關於 slice
slice 翻譯成中文就是切片，它和數組（array）很類似，可以用下標的方式進行訪問，如果越界，就會產生 panic。但是它比數組更靈活，可以自動地進行擴容。
瞭解 slice 的本質，最簡單的方法就是看它的源代碼：
1 // runtime/slice.go
2 type slice struct {
3 array unsafe.Pointer // 元素指針
4 len int // 長度
5 cap int // 容量
6 }看到了嗎，slice 共有三個屬性： 指針，指向底層數組； 長度，表示切片可用元素的個數，也就是說使用下標對 slice 的元素進行訪問時，下標不能超過 slice 的長度； 容量，底層數組的元素個數，容量 >= 長度。在底層數組不進行擴容的情況下，容量也是 slice 可以擴張的最大限度。
▎直接聲明
第一種創建出來的 slice 其實是一個 nil slice。它的長度和容量都爲0。和nil比較的結果爲true。
這裏比較混淆的是 empty slice，它的長度和容量也都爲 0 ，但是所有的空切片的數據指針都指向同一個地址 0xc42003bda0 。空切片和 nil 比較的結果爲 false 。
它們的內部結構如下圖：
nil 切片和空切片很相似，長度和容量都是0，官方建議儘量使用 nil 切片。
關於nil slice和empty slice的探索可以參考公衆號“碼洞”作者老錢寫的一篇文章《深度解析 Go 語言中「切片」的三種特殊狀態》，地址附在了參考資料部分。
▎字面量
比較簡單，直接用初始化表達式創建。
1 package main
2
3 import "fmt"
4
5 func main() {
6 s1 := []int{0, 1, 2, 3, 8: 100}
7 fmt.Println(s1, len(s1), cap(s1))
8 }運行結果：
1 [0 1 2 3 0 0 0 0 100] 9 9唯一值得注意的是上面的代碼例子中使用了索引號，直接賦值，這樣，其他未註明的元素則默認 0 值。
▎make
make函數需要傳入三個參數：切片類型，長度，容量。當然，容量可以不傳，默認和長度相等。
在《走進Go的底層》文章中，我們學到了彙編這個工具，這次我們再次請出彙編來更深入地看看slice。建議先看完上一篇，再繼續閱讀本文效果更佳。
先來一小段玩具代碼，使用 make 關鍵字創建 slice：
1 package main
2
3 import "fmt"
4
5 func main() {
6 slice := make([]int, 5, 10) // 長度爲5，容量爲10
7 slice[2] = 2 // 索引爲2的元素賦值爲2
8 fmt.Println(slice)
9 }執行如下命令，得到 Go 彙編代碼：
1 go tool compile -S main.go我們只關注main函數：
1 0x0000 00000 (main.go:5)TEXT "".main(SB), $96-0
2 0x0000 00000 (main.go:5)MOVQ (TLS), CX
3 0x0009 00009 (main.go:5)CMPQ SP, 16(CX)
4 0x000d 00013 (main.go:5)JLS 228
5 0x0013 00019 (main.go:5)SUBQ $96, SP
6 0x0017 00023 (main.go:5)MOVQ BP, 88(SP)
7 0x001c 00028 (main.go:5)LEAQ 88(SP), BP
8 0x0021 00033 (main.go:5)FUNCDATA $0,
gclocals·69c1753bd5f81501d95132d08af04464(SB)
9 0x0021 00033 (main.go:5)FUNCDATA $1, gclocals·57cc5e9a024203768cbab1c731570886(SB)
10 0x0021 00033 (main.go:5)LEAQ type.int(SB), AX
11 0x0028 00040 (main.go:6)MOVQ AX, (SP)
12 0x002c 00044 (main.go:6)MOVQ $5, 8(SP)
13 0x0035 00053 (main.go:6)MOVQ $10, 16(SP)
14 0x003e 00062 (main.go:6)PCDATA $0, $0
15 0x003e 00062 (main.go:6)CALL runtime.makeslice(SB)
16 0x0043 00067 (main.go:6)MOVQ 24(SP), AX
17 0x0048 00072 (main.go:6)MOVQ 32(SP), CX
18 0x004d 00077 (main.go:6)MOVQ 40(SP), DX
19 0x0052 00082 (main.go:7)CMPQ CX, $2
20 0x0056 00086 (main.go:7)JLS 221
21 0x005c 00092 (main.go:7)MOVQ $2, 16(AX)
22 0x0064 00100 (main.go:8)MOVQ AX, ""..autotmp_2+64(SP)
23 0x0069 00105 (main.go:8)MOVQ CX, ""..autotmp_2+72(SP)
24 0x006e 00110 (main.go:8)MOVQ DX, ""..autotmp_2+80(SP)
25 0x0073 00115 (main.go:8)MOVQ $0, ""..autotmp_1+48(SP)
26 0x007c 00124 (main.go:8)MOVQ $0, ""..autotmp_1+56(SP)
27 0x0085 00133 (main.go:8)LEAQ type.[]int(SB), AX
28 0x008c 00140 (main.go:8)MOVQ AX, (SP)
29 0x0090 00144 (main.go:8)LEAQ ""..autotmp_2+64(SP), AX
30 0x0095 00149 (main.go:8)MOVQ AX, 8(SP)
31 0x009a 00154 (main.go:8)PCDATA $0, $1
32 0x009a 00154 (main.go:8)CALL runtime.convT2Eslice(SB)
33 0x009f 00159 (main.go:8)MOVQ 16(SP), AX
34 0x00a4 00164 (main.go:8)MOVQ 24(SP), CX
35 0x00a9 00169 (main.go:8)MOVQ AX, ""..autotmp_1+48(SP)
36 0x00ae 00174 (main.go:8)MOVQ CX, ""..autotmp_1+56(SP)
37 0x00b3 00179 (main.go:8)LEAQ ""..autotmp_1+48(SP), AX
38 0x00b8 00184 (main.go:8)MOVQ AX, (SP)
39 0x00bc 00188 (main.go:8)MOVQ $1, 8(SP)
40 0x00c5 00197 (main.go:8)MOVQ $1, 16(SP)
41 0x00ce 00206 (main.go:8)PCDATA $0, $1
42 0x00ce 00206 (main.go:8)CALL fmt.Println(SB)
43 0x00d3 00211 (main.go:9)MOVQ 88(SP), BP
44 0x00d8 00216 (main.go:9)ADDQ $96, SP
45 0x00dc 00220 (main.go:9)RET
46 0x00dd 00221 (main.go:7)PCDATA $0, $0
47 0x00dd 00221 (main.go:7)CALL runtime.panicindex(SB)
48 0x00e2 00226 (main.go:7)UNDEF
49 0x00e4 00228 (main.go:7)NOP
50 0x00e4 00228 (main.go:5)PCDATA $0, $-1
51 0x00e4 00228 (main.go:5)CALL runtime.morestack_noctxt(SB)
52 0x00e9 00233 (main.go:5)JMP 0先說明一下，Go 語言彙編 FUNCDATA 和 PCDATA 是編譯器產生的，用於保存一些和垃圾收集相關的信息，我們先不用 care。
以上彙編代碼行數比較多，沒關係，因爲命令都比較簡單，而且我們的 Go 源碼也足夠簡單，沒有理由看不明白。
我們先從上到下掃一眼，看到幾個關鍵函數：
1 CALL runtime.makeslice(SB)
2 CALL runtime.convT2Eslice(SB)
3 CALL fmt.Println(SB)
4 CALL runtime.morestack_noctxt(SB)
1 是創建 slice 相關的；2 是類型轉換；調用 fmt.Println 需要將 slice 作一個轉換； 3 是打印語句；4是棧空間擴容函數，在函數開始處，會檢查當前棧空間是否足夠，不夠的話需要調用它來進行擴容。暫時可以忽略。
調用了函數就會涉及到參數傳遞，Go 的參數傳遞都是通過 棧空間完成的。接下來，我們詳細分析這整個過程。
左邊是棧上的數據，右邊是堆上的數據。array 指向 slice 的底層數據，被分配到堆上了。注意，棧上的地址是從高向低增長；堆則從低向高增長。棧左邊的數字表示對應的彙編代碼的行數，棧右邊箭頭則表示棧地址。（48）SP、（56）SP 表示的內容接着往下看。
注意，在圖中，棧地址是從下往上增長，所以 SP 表示的是圖中 *_type 所在的位置，其它的依此類推。
convT2Eslice 的函數聲明如下：
1 func convT2Eslice(t *_type, elem unsafe.Pointer) (e eface) 第一個參數是指針 *_type，_type是一個表示類型的結構體，這裏傳入的就是 slice的類型 []int；第二個參數則是元素的指針，這裏傳入的就是 slice 底層數組的首地址。
返回值 eface 的結構體定義如下：
1 type eface struct {
2 _type *_type
3 data unsafe.Pointer
4 }由於我們會調用 fmt.Println(slice)，看下函數原型：
1 func Println(a ...interface{}) (n int, err error)Println 接收 interface 類型，因此我們需要將 slice 轉換成 interface 類型。由於 slice 沒有方法，是個“空 interface”。因此會調用 convT2Eslice 完成這一轉換過程。
convT2Eslice 函數返回的是類型指針和數據地址。源碼就不貼了，大體流程是：調用 mallocgc 分配一塊內存，把數據 copy 進到新的內存，然後返回這塊內存的地址，*_type 則直接返回傳入的參數。
32(SP) 和 40(SP) 其實是 makeslice 函數的返回值，這裏可以忽略。
還剩 fmt.Println(slice) 最後一個函數調用了，我們繼續。
最後，我們看下 main 函數棧幀的開始和收尾部分。
1 0x0013 00019 (main.go:5)SUBQ $96, SP
2 0x0017 00023 (main.go:5)MOVQ BP, 88(SP)
3 0x001c 00028 (main.go:5)LEAQ 88(SP), BP
4 …………………………
5 0x00d3 00211 (main.go:9)MOVQ 88(SP), BP
6 0x00d8 00216 (main.go:9)ADDQ $96, SP
7 RETBP 可以理解爲保存了當前函數棧幀棧底的地址，SP則保存棧頂的地址。
初始，BP 和 SP 分別有一個初始狀態。
main 函數執行的時候，先根據 main 函數棧幀大小確定 SP 的新指向，使得 main 函數棧幀大小達到 96B。之後把老的 BP 保存到 main 函數棧幀的底部，並使 BP 寄存器重新指向新的棧底，也就是 main 函數棧幀的棧底。
最後，當 main 函數執行完畢，把它棧底的 BP 給回彈回到 BP 寄存器，恢復調用前的初始狀態。一切都像是沒有發生一樣，完美的現場。
這部分，又詳細地分析了一遍函數調用的過程。一方面，讓大家複習一下上一篇文章講的內容；另一方面，向大家展示如何找到 Go 中的一個函數背後真實調用了哪些函數。像例子中，我們就看到了 make 函數背後，實際上是調用了 makeslice 函數；還有一點，讓大家對彙編不那麼“懼怕”，可以輕鬆地分析一些東西。
▎截取
截取也是比較常見的一種創建 slice 的方法，可以從數組或者 slice 直接截取，當然需要指定起止索引位置。
基於已有 slice 創建新 slice 對象，被稱爲 reslice。新 slice 和老 slice 共用底層數組，新老 slice 對底層數組的更改都會影響到彼此。基於數組創建的新 slice 對象也是同樣的效果：對數組或 slice 元素作的更改都會影響到彼此。
值得注意的是，新老 slice 或者新 slice 老數組互相影響的前提是兩者共用底層數組，如果因爲執行 append 操作使得新 slice 底層數組擴容，移動到了新的位置，兩者就不會相互影響了。所以，問題的關鍵在於兩者是否會共用底層數組。
截取操作採用如下方式：
1 data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
2 slice := data[2:4:6] // data[low, high, max]對 data 使用3個索引值，截取出新的 slice 。這裏 data 可以是數組或者 slice。low 是最低索引值，這裏是閉區間，也就是說第一個元素是 data 位於 low 索引處的元素；而 high 和 max 則是開區間，表示最後一個元素只能是索引 high-1 處的元素，而最大容量則只能是索引 max-1 處的元素。
1 max >= high >= low當 high == low 時，新 slice 爲空。
還有一點，high 和 max 必須在老數組或者老 slice 的容量（cap）範圍內。
來看一個例子，來自雨痕大佬《Go學習筆記》第四版，P43頁，參考資料裏有開源書籍地址。這裏我會進行擴展，並會作詳細說明：
1 package main
2
3 import "fmt"
4
5 func main() {
6 slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
7 s1 := slice[2:5]
8 s2 := s1[2:6:7]
9
10 s2 = append(s2, 100)
11 s2 = append(s2, 200)
12
13 s1[2] = 20
14
15 fmt.Println(s1)
16 fmt.Println(s2)
17 fmt.Println(slice)
18 }先看下代碼運行的結果：
1 [2 3 20]
2 [4 5 6 7 100 200]
3 [0 1 2 3 20 5 6 7 100 9]我們來走一遍代碼，初始狀態如下：
1 slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
2 s1 := slice[2:5]
3 s2 := s1[2:6:7]s1 從 slice 索引2（閉區間）到索引5（開區間，元素真正取到索引4），長度爲3，容量默認到數組結尾，爲8。 s2 從 s1 的索引2（閉區間）到索引6（開區間，元素真正取到索引5），容量到索引7（開區間，真正到索引6），爲5。
接着，向 s2 尾部追加一個元素 100：
1 s2 = append(s2, 100)s2 容量剛好夠，直接追加。不過，這會修改原始數組對應位置的元素。這一改動，數組和 s1 都可以看得到。
再次向 s2 追加元素200：
1 s2 = append(s2, 100)這時，s2 的容量不夠用，該擴容了。於是，s2 另起爐竈，將原來的元素複製新的位置，擴大自己的容量。並且爲了應對未來可能的 append 帶來的再一次擴容，s2 會在此次擴容的時候多留一些 buffer，將新的容量將擴大爲原始容量的2倍，也就是10了。
最後，修改 s1 索引爲2位置的元素：
1 s1[2] = 20這次只會影響原始數組相應位置的元素。它影響不到 s2 了，人家已經遠走高飛了。
再提一點，打印 s1 的時候，只會打印出 s1 長度以內的元素。所以，只會打印出3個元素，雖然它的底層數組不止3個元素。
至於，我們想在彙編層面看看到底它們是如何共享底層數組的，限於篇幅，這裏不再展開。感興趣的同學可以在公衆號後臺回覆：切片截取。
我會給你詳細分析函數調用關係，對共享底層數組的行爲也會一目瞭然。
▎slice 和數組的區別在哪
slice 的底層數據是數組，slice 是對數組的封裝，它描述一個數組的片段。兩者都可以通過下標來訪問單個元素。
數組是定長的，長度定義好之後，不能再更改。在 Go 中，數組是不常見的，因爲其長度是類型的一部分，限制了它的表達能力，比如 [3]int 和 [4]int 就是不同的類型。
而切片則非常靈活，它可以動態地擴容。切片的類型和長度無關。
▎append 到底做了什麼
先來看看 append 函數的原型：
1 func append(slice []Type, elems ...Type) []Typeappend 函數的參數長度可變，因此可以追加多個值到 slice 中，還可以用 ... 傳入 slice，直接追加一個切片。
1 slice = append(slice, elem1, elem2)
2 slice = append(slice, anotherSlice...)append函數返回值是一個新的slice，Go編譯器不允許調用了 append 函數後不使用返回值。
1 append(slice, elem1, elem2)
2 append(slice, anotherSlice...)所以上面的用法是錯的，不能編譯通過。
使用 append 可以向 slice 追加元素，實際上是往底層數組添加元素。但是底層數組的長度是固定的，如果索引 len-1 所指向的元素已經是底層數組的最後一個元素，就沒法再添加了。
這時，slice 會遷移到新的內存位置，新底層數組的長度也會增加，這樣就可以放置新增的元素。同時，爲了應對未來可能再次發生的 append 操作，新的底層數組的長度，也就是新 slice 的容量是留了一定的 buffer 的。否則，每次添加元素的時候，都會發生遷移，成本太高。
新 slice 預留的 buffer 大小是有一定規律的。網上大多數的文章都是這樣描述的：
當原 slice 容量小於 1024 的時候，新 slice 容量變成原來的 2 倍；原 slice 容量超過 1024，新 slice 容量變成原來的1.25倍。
我在這裏先說結論：以上描述是錯誤的。
爲了說明上面的規律是錯誤的，我寫了一小段玩具代碼：
1 package main
2
3 import "fmt"
4
5 func main() {
6 s := make([]int, 0)
7
8 oldCap := cap(s)
9
10 for i := 0; i < 2048; i++ {
11 s = append(s, i)
12
13 newCap := cap(s)
14
15 if newCap != oldCap {
16 fmt.Printf("[%d -> %4d] cap = %-4d | after append %-4d cap = %-4d\n", 0, i-1, oldCap, i, newCap)
17 oldCap = newCap
18 }
19 }
20 }我先創建了一個空的 slice，然後，在一個循環裏不斷往裏面 append 新的元素。然後記錄容量的變化，並且每當容量發生變化的時候，記錄下老的容量，以及添加完元素之後的容量，同時記下此時 slice 裏的元素。這樣，我就可以觀察，新老 slice 的容量變化情況，從而找出規律。
運行結果：
1 [0 -> -1] cap = 0 | after append 0 cap = 1
2 [0 -> 0] cap = 1 | after append 1 cap = 2
3 [0 -> 1] cap = 2 | after append 2 cap = 4
4 [0 -> 3] cap = 4 | after append 4 cap = 8
5 [0 -> 7] cap = 8 | after append 8 cap = 16
6 [0 -> 15] cap = 16 | after append 16 cap = 32
7 [0 -> 31] cap = 32 | after append 32 cap = 64
8 [0 -> 63] cap = 64 | after append 64 cap = 128
9 [0 -> 127] cap = 128 | after append 128 cap = 256
10 [0 -> 255] cap = 256 | after append 256 cap = 512
11 [0 -> 511] cap = 512 | after append 512 cap = 1024
12 [0 -> 1023] cap = 1024 | after append 1024 cap = 1280
13 [0 -> 1279] cap = 1280 | after append 1280 cap = 1696
14 [0 -> 1695] cap = 1696 | after append 1696 cap = 2304在老 slice 容量小於1024的時候，新 slice 的容量的確是老 slice 的2倍。目前還算正確。
但是，當老 slice 容量大於等於 1024 的時候，情況就有變化了。當向 slice 中添加元素 1280 的時候，老 slice 的容量爲 1280，之後變成了 1696，兩者並不是 1.25 倍的關係（1696/1280=1.325）。添加完 1696 後，新的容量 2304 當然也不是 1696 的 1.25 倍。
可見，現在網上各種文章中的擴容策略並不正確。我們直接搬出源碼：源碼面前，了無祕密。
從前面彙編代碼我們也看到了，向 slice 追加元素的時候，若容量不夠，會調用 growslice 函數，所以我們直接看它的代碼。
1 // go 1.9.5 src/runtime/slice.go:82
2 func growslice(et *_type, old slice, cap int) slice {
3 // ……
4 newcap := old.cap
5 doublecap := newcap + newcap
6 if cap > doublecap {
7 newcap = cap
8 } else {
9 if old.len < 1024 {
10 newcap = doublecap
11 } else {
12 for newcap < cap {
13 newcap += newcap / 4
14 }
15 }
16 }
17 // ……
18
19 capmem = roundupsize(uintptr(newcap) * ptrSize)
20 newcap = int(capmem / ptrSize)
21 }看到了嗎？如果只看前半部分，現在網上各種文章裏說的 newcap 的規律是對的。現實是，後半部分還對 newcap 作了一個內存對齊，這個和內存分配策略相關。進行內存對齊之後，新 slice 的容量是要 大於等於 老 slice 容量的 2倍或者1.25倍。
之後，向 Go 內存管理器申請內存，將老 slice 中的數據複製過去，並且將 append 的元素添加到新的底層數組中。
最後，向 growslice 函數調用者返回一個新的 slice，這個 slice 的長度並沒有變化，而容量卻增大了。
關於 append，我們最後來看一個例子，來源於參考資料部分的【Golang Slice的擴容規則】。
1 package main
2
3 import "fmt"
4
5 func main() {
6 s := []int{1,2}
7 s = append(s,4,5,6)
8 fmt.Printf("len=%d, cap=%d",len(s),cap(s))
9 }
運行結果是：
1 len=5, cap=6如果按網上各種文章中總結的那樣：小於原 slice 長度小於 1024 的時候，容量每次增加 1 倍。添加元素 4 的時候，容量變爲4；添加元素 5 的時候不變；添加元素 6 的時候容量增加 1 倍，變成 8。
那上面代碼的運行結果就是：
1 len=5, cap=8這是錯誤的！我們來仔細看看，爲什麼會這樣，再次搬出代碼：
1 // go 1.9.5 src/runtime/slice.go:82
2 func growslice(et *_type, old slice, cap int) slice {
3 // ……
4 newcap := old.cap
5 doublecap := newcap + newcap
6 if cap > doublecap {
7 newcap = cap
8 } else {
9 // ……
10 }
11 // ……
12
13 capmem = roundupsize(uintptr(newcap) * ptrSize)
14 newcap = int(capmem / ptrSize)
15 }這個函數的參數依次是 元素的類型，老的 slice，新 slice 最小求的容量。
例子中 s 原來只有 2 個元素，len 和 cap 都爲 2，append 了三個元素後，長度變爲 3，容量最小要變成 5，即調用 growslice 函數時，傳入的第三個參數應該爲 5。即 cap=5。而一方面，doublecap 是原 slice容量的 2 倍，等於 4。滿足第一個 if 條件，所以 newcap 變成了 5。
接着調用了 roundupsize 函數，傳入 40。（代碼中ptrSize是指一個指針的大小，在64位機上是8）
我們再看內存對齊，搬出 roundupsize 函數的代碼：
1 // src/runtime/msize.go:13func roundupsize(size uintptr) uintptr { if size < _MaxSmallSize { if size <= smallSizeMax-8 { return uintptr(class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]]) } else { //…… } } //……}const _MaxSmallSize = 32768const smallSizeMax = 1024const smallSizeDiv = 8
很明顯，我們最終將返回這個式子的結果：
1 class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]]這是 Go 源碼中有關內存分配的兩個 slice。class_to_size通過 spanClass獲取 span劃分的 object大小。而 size_to_class8 表示通過 size 獲取它的 spanClass。
1 var size_to_class8 = [smallSizeMax/smallSizeDiv + 1]uint8{0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31}
2 var class_to_size = [_NumSizeClasses]uint16{0, 8, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304, 2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144, 6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880, 12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760, 24576, 27264, 28672, 32768}
我們傳進去的 size 等於 40。所以 (size+smallSizeDiv-1)/smallSizeDiv = 5；獲取 size_to_class8 數組中索引爲 5 的元素爲 4；獲取 class_to_size 中索引爲 4 的元素爲 48。
最終，新的 slice 的容量爲 6：
1 newcap = int(capmem / ptrSize) // 6至於，上面的兩個魔法數組的由來，暫時就不展開了。
▎爲什麼 nil slice 可以直接 append
其實 nil slice 或者 empty slice 都是可以通過調用 append 函數來獲得底層數組的擴容。最終都是調用 mallocgc 來向 Go 的內存管理器申請到一塊內存，然後再賦給原來的nil slice 或 empty slice，然後搖身一變，成爲“真正”的 slice 了。
▎傳 slice 和 slice 指針有什麼區別
前面我們說到，slice 其實是一個結構體，包含了三個成員：len, cap, array。分別表示切片長度，容量，底層數據的地址。
當 slice 作爲函數參數時，就是一個普通的結構體。其實很好理解：若直接傳 slice，在調用者看來，實參 slice 並不會被函數中的操作改變；若傳的是 slice 的指針，在調用者看來，是會被改變原 slice 的。
值的注意的是，不管傳的是 slice 還是 slice 指針，如果改變了 slice 底層數組的數據，會反應到實參 slice 的底層數據。爲什麼能改變底層數組的數據？很好理解：底層數據在 slice 結構體裏是一個指針，僅管 slice 結構體自身不會被改變，也就是說底層數據地址不會被改變。 但是通過指向底層數據的指針，可以改變切片的底層數據，沒有問題。
通過 slice 的 array 字段就可以拿到數組的地址。在代碼裏，是直接通過類似 s[i]=10 這種操作改變 slice 底層數組元素值。
另外，囉嗦一句，Go 語言的函數參數傳遞，只有值傳遞，沒有引用傳遞。後面會再寫一篇相關的文章，敬請期待。
再來看一個年幼無知的代碼片段：
1 package main
2
3 func main() {
4 s := []int{1, 1, 1}
5 f(s)
6 fmt.Println(s)
7 }
8
9 func f(s []int) {
10 // i只是一個副本，不能改變s中元素的值
11 /*for _, i := range s {
12 i++
13 }
14 */
15
16 for i := range s {
17 s[i] += 1
18 }
19 }運行一下，程序輸出：
1 [2 2 2]果真改變了原始 slice 的底層數據。這裏傳遞的是一個 slice 的副本，在 f 函數中，s 只是 main 函數中 s 的一個拷貝。在f 函數內部，對 s 的作用並不會改變外層 main 函數的 s。
要想真的改變外層 slice，只有將返回的新的 slice 賦值到原始 slice，或者向函數傳遞一個指向 slice 的指針。我們再來看一個例子：
1 package main
2
3 import "fmt"
4
5 func myAppend(s []int) []int {
6 // 這裏 s 雖然改變了，但並不會影響外層函數的 s
7 s = append(s, 100)
8 return s
9 }
10
11 func myAppendPtr(s *[]int) {
12 // 會改變外層 s 本身
13 *s = append(*s, 100)
14 return
15 }
16
17 func main() {
18 s := []int{1, 1, 1}
19 newS := myAppend(s)
20
21 fmt.Println(s)
22 fmt.Println(newS)
23
24 s = newS
25
26 myAppendPtr(&s)
27 fmt.Println(s)
28 }運行結果：
1 [1 1 1]
2 [1 1 1 100]
3 [1 1 1 100 100]myAppend 函數裏，雖然改變了 s，但它只是一個值傳遞，並不會影響外層的 s，因此第一行打印出來的結果仍然是 [1 1 1]。
而 newS 是一個新的 slice，它是基於 s 得到的。因此它打印的是追加了一個 100 之後的結果： [1 1 1 100]。
最後，將 newS 賦值給了 s，s 這時才真正變成了一個新的slice。之後，再給 myAppendPtr 函數傳入一個 s 指針，這回它真的被改變了：[1 1 1 100 100]。
▎總結
到此，關於 slice 的部分就講完了，不知大家有沒有看過癮。我們最後來總結一下：
- 切片是對底層數組的一個抽象，描述了它的一個片段。
- 切片實際上是一個結構體，它有三個字段：長度，容量，底層數據的地址。
- 多個切片可能共享同一個底層數組，這種情況下，對其中一個切片或者底層數組的更改，會影響到其他切片。
- append 函數會在切片容量不夠的情況下，調用 growslice 函數獲取所需要的內存，這稱爲擴容，擴容會改變元素原來的位置。
- 擴容策略並不是簡單的擴爲原切片容量的 2 倍或 1.25 倍，還有內存對齊的操作。擴容後的容量 >= 原容量的 2 倍或 1.25 倍。
- 當直接用切片作爲函數參數時，可以改變切片的元素，不能改變切片本身；想要改變切片本身，可以將改變後的切片返回，函數調用者接收改變後的切片或者將切片指針作爲函數參數。
▎END
參考資料如下
https://z.didi.cn/1HGeUj
畢業於中科院計算所。17年加入滴滴引擎技術部，負責供需系統的後端研發。Go語言愛好者，熱衷於探究技術背後的原理。
