從零開始學習 Go 語言的切片
這篇文章受到了我與同事討論使用 切片 作為 棧 的一次聊天的啟發。後來話題聊到了 Go 語言中的切片是如何工作的。我認為這些信息對別人也有用，所以就把它記錄了下來。
數組
任何關於 Go 語言切片的討論都要從另一個數據結構也就是 數組 開始。Go 的數組有兩個特性：
- 數組的長度是固定的；
[5]int是由 5 個int構成的數組，和[3]int不同。 - 數組是值類型。看下面這個示例：
package main
import "fmt"
func main() {
var a [5]int
b := a
b[2] = 7
fmt.Println(a, b) // prints [0 0 0 0 0] [0 0 7 0 0]
}語句 b := a 定義了一個類型是 [5]int 的新變數 b，然後把 a 中的內容 複製 到 b 中。改變 b 對 a 中的內容沒有影響，因為 a 和 b 是相互獨立的值。 1
切片
Go 語言的切片和數組的主要有如下兩個區別：
- 切片沒有一個固定的長度。切片的長度不是它類型定義的一部分，而是由切片內部自己維護的。我們可以使用內置的
len函數知道它的長度。 2 - 將一個切片賦值給另一個切片時 不會 對切片內容進行複製操作。這是因為切片沒有直接持有其內部數據，而是保留了一個指向 底層數組 3 的指針。數據都保留在底層數組裡。
基於第二個特性，兩個切片可以享有共同的底層數組。看下面的示例：
- 對切片取切片
package main
import "fmt"
func main() {
var a = []int{1,2,3,4,5}
b := a[2:]
b[0] = 0
fmt.Println(a, b) // prints [1 2 0 4 5] [0 4 5]
}在這個例子里，a 和 b 享有共同的底層數組 —— 儘管 b 在數組裡的起始偏移量不同，兩者的長度也不同。通過 b 修改底層數組的值也會導致 a 里的值的改變。
- 將切片傳進函數
package main
import "fmt"
func negate(s []int) {
for i := range s {
s[i] = -s[i]
}
}
func main() {
var a = []int{1, 2, 3, 4, 5}
negate(a)
fmt.Println(a) // prints [-1 -2 -3 -4 -5]
}在這個例子里，a 作為形參 s 的實參傳進了 negate 函數，這個函數遍歷 s 內的元素並改變其符號。儘管 nagate 沒有返回值，且沒有訪問到 main 函數里的 a。但是當將之傳進 negate 函數內時，a 裡面的值卻被改變了。
大多數程序員都能直觀地了解 Go 語言切片的底層數組是如何工作的，因為它與其它語言中類似數組的工作方式類似。比如下面就是使用 Python 重寫的這一小節的第一個示例：
Python 2.7.10 (default, Feb 7 2017, 00:08:15)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a = [1,2,3,4,5]
>>> b = a
>>> b[2] = 0
>>> a
[1, 2, 0, 4, 5]以及使用 Ruby 重寫的版本:
irb(main):001:0> a = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> b = a
=> [1, 2, 3, 4, 5]
irb(main):003:0> b[2] = 0
=> 0
irb(main):004:0> a
=> [1, 2, 0, 4, 5]在大多數將數組視為對象或者是引用類型的語言也是如此。 4
切片頭
切片同時擁有值和指針特性的神奇之處在於理解切片實際上是一個 結構體 類型。通常在 反射 包內相應部分之後的這個結構體被稱作 切片頭 。切片頭的定義大致如下：
package runtime
type slice struct {
ptr unsafe.Pointer
len int
cap int
}這很重要，因為和 map 以及 chan 這兩個類型不同，切片是值類型，當被賦值或者被作為參數傳入函數時候會被複制過去。
程序員們都能理解 square 的形參 v 和 main 中聲明的 v 的是相互獨立的。請看下面的例子：
package main
import "fmt"
func square(v int) {
v = v * v
}
func main() {
v := 3
square(v)
fmt.Println(v) // prints 3, not 9
}因此 square 對自己的形參 v 的操作沒有影響到 main 中的 v。下面這個示例中的 s 也是 main 中聲明的切片 s 的獨立副本， 而不是 指向 main 的 s 的指針。
package main
import "fmt"
func double(s []int) {
s = append(s, s...)
}
func main() {
s := []int{1, 2, 3}
double(s)
fmt.Println(s, len(s)) // prints [1 2 3] 3
}Go 的切片是作為值傳遞而不是指針這一點不太尋常。當你在 Go 內定義一個結構體時，90% 的時間裡傳遞的都是這個結構體的指針 5 。切片的傳遞方式真的很不尋常，我能想到的唯一與之相同的例子只有 time.Time。
切片作為值傳遞而不是作為指針傳遞這一特殊行為會讓很多想要理解切片的工作原理的 Go 程序員感到困惑。你只需要記住，當你對切片進行賦值、取切片、傳參或者作為返回值等操作時，你是在複製切片頭結構的三個欄位：指向底層數組的指針、長度，以及容量。
總結
我們來用引出這一話題的切片作為棧的例子來總結下本文的內容：
package main
import "fmt"
func f(s []string, level int) {
if level > 5 {
return
}
s = append(s, fmt.Sprint(level))
f(s, level+1)
fmt.Println("level:", level, "slice:", s)
}
func main() {
f(nil, 0)
}在 main 函數的最開始我們把一個 nil 切片傳給了函數 f 作為 level 0 。在函數 f 里我們把當前的 level 添加到切片的後面，之後增加 level 的值並進行遞歸。一旦 level 大於 5，函數返回，列印出當前的 level 以及它們複製到的 s 的內容。
level: 5 slice: [0 1 2 3 4 5]
level: 4 slice: [0 1 2 3 4]
level: 3 slice: [0 1 2 3]
level: 2 slice: [0 1 2]
level: 1 slice: [0 1]
level: 0 slice: [0]你可以注意到在每一個 level 內 s 的值沒有被別的 f 的調用影響，儘管當計算更高的 level 時作為 append 的副產品，調用棧內的四個 f 函數創建了四個底層數組 6 ，但是沒有影響到當前各自的切片。
擴展閱讀
如果你想要了解更多 Go 語言內切片運行的原理，我建議看看 Go 博客里的這些文章：
- Go Slices: usage and internals (blog.golang.org)
- Arrays, slices (and strings): The mechanics of 'append' (blog.golang.org)
相關文章：
-
這不是數組才有的特性，在 Go 語言里中 一切 賦值都是複製過去的。 ↩
-
你也可以在對數組使用
len函數，但是其結果本來就人盡皆知。 ↩ -
有時也叫做 後台數組 ，以及更不嚴謹的說法是後台切片。 ↩
-
Go 語言里我們傾向於說值類型以及指針類型，因為 C++ 的 引用 類型這個詞產生誤會。但在這裡我認為調用數組作為引用類型是沒有問題的。 ↩
-
如果你的結構體有定義在其上的方法或者用於滿足某個介面，那麼你傳入結構體指針的比率可以飆升到接近 100%。 ↩
-
證明留做習題。 ↩
via: https://dave.cheney.net/2018/07/12/slices-from-the-ground-up
作者：Dave Cheney 譯者：name1e5s 校對：pityonline
本文轉載來自 Linux 中國: https://github.com/Linux-CN/archive
對這篇文章感覺如何？
You may also like
More in:Linux中國
如何通過 VLC 使用字幕
Unix 桌面：在 Linux 問世之前
Valve 對於 Ubuntu 的 Snap 版本的 Steam 並不滿意：原因何在
Wine 9.0 發布，實驗性地加入了 Wayland 驅動
