4.2. Slice
Slice（切片）代表變長的序列，序列中每個元素都有相同的類型。一個slice類型一般寫作[]T，其中T代表slice中元素的類型；slice的語法和數組很像，只是沒有固定長度而已。
數組和slice之間有著緊密的聯繫。一個slice是一個輕量級的數據結構，提供了訪問數組子序列（或者全部）元素的功能，而且slice的底層確實引用一個數組對象。一個slice由三個部分構成：指針、長度和容量。指針指向第一個slice元素對應的底層數組元素的地址，要注意的是slice的第一個元素並不一定就是數組的第一個元素。長度對應slice中元素的數目；長度不能超過容量，容量一般是從slice的開始位置到底層數據的結尾位置。內置的len和cap函數分別返回slice的長度和容量。
多個slice之間可以共享底層的數據，並且引用的數組部分區間可能重疊。圖4.1顯示了表示一年中每個月份名字的字符串數組，還有重疊引用了該數組的兩個slice。數組這樣定義
months := [...]string{1: "January", /* ... */, 12: "December"}
因此一月份是months[1]，十二月份是months[12]。通常，數組的第一個元素從索引0開始，但是月份一般是從1開始的，因此我們聲明數組時直接跳過第0個元素，第0個元素會被自動初始化為空字符串。
slice的切片操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用於創建一個新的slice，引用s的從第i個元素開始到第j-1個元素的子序列。新的slice將只有j-i個元素。如果i位置的索引被省略的話將使用0代替，如果j位置的索引被省略的話將使用len(s)代替。因此，months[1:13]切片操作將引用全部有效的月份，和months[1:]操作等價；months[:]切片操作則是引用整個數組。讓我們分別定義表示第二季度和北方夏天月份的slice，它們有重疊部分：
Q2 := months[4:7]
summer := months[6:9]
fmt.Println(Q2) // ["April" "May" "June"]
fmt.Println(summer) // ["June" "July" "August"]
兩個slice都包含了六月份，下面的代碼是一個包含相同月份的測試（性能較低）：
for _, s := range summer {
for _, q := range Q2 {
if s == q {
fmt.Printf("%s appears in both\n", s)
}
}
}
如果切片操作超出cap(s)的上限將導致一個panic異常，但是超出len(s)則是意味著擴展了slice，因為新slice的長度會變大：
fmt.Println(summer[:20]) // panic: out of range
endlessSummer := summer[:5] // extend a slice (within capacity)
fmt.Println(endlessSummer) // "[June July August September October]"
另外，字符串的切片操作和[]byte字節類型切片的切片操作是類似的。都寫作x[m:n]，並且都是返回一個原始字節序列的子序列，底層都是共享之前的底層數組，因此這種操作都是常量時間複雜度。x[m:n]切片操作對於字符串則生成一個新字符串，如果x是[]byte的話則生成一個新的[]byte。
因為slice值包含指向第一個slice元素的指針，因此向函數傳遞slice將允許在函數內部修改底層數組的元素。換句話說，複製一個slice只是對底層的數組創建了一個新的slice別名（§2.3.2）。下面的reverse函數在原內存空間將[]int類型的slice反轉，而且它可以用於任意長度的slice。
gopl.io/ch4/rev
// reverse reverses a slice of ints in place.
func reverse(s []int) {
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
s[i], s[j] = s[j], s[i]
}
}
這裡我們反轉數組的應用：
a := [...]int{0, 1, 2, 3, 4, 5}
reverse(a[:])
fmt.Println(a) // "[5 4 3 2 1 0]"
一種將slice元素循環向左旋轉n個元素的方法是三次調用reverse反轉函數，第一次是反轉開頭的n個元素，然後是反轉剩下的元素，最後是反轉整個slice的元素。（如果是向右循環旋轉，則將第三個函數調用移到第一個調用位置就可以了。）
s := []int{0, 1, 2, 3, 4, 5}
// Rotate s left by two positions.
reverse(s[:2])
reverse(s[2:])
reverse(s)
fmt.Println(s) // "[2 3 4 5 0 1]"
要注意的是slice類型的變量s和數組類型的變量a的初始化語法的差異。slice和數組的字面值語法很類似，它們都是用花括弧包含一系列的初始化元素，但是對於slice並沒有指明序列的長度。這會隱式地創建一個合適大小的數組，然後slice的指針指向底層的數組。就像數組字面值一樣，slice的字面值也可以按順序指定初始化值序列，或者是通過索引和元素值指定，或者用兩種風格的混合語法初始化。
和數組不同的是，slice之間不能比較，因此我們不能使用==操作符來判斷兩個slice是否含有全部相等元素。不過標準庫提供了高度優化的bytes.Equal函數來判斷兩個字節型slice是否相等（[]byte），但是對於其他類型的slice，我們必須自己展開每個元素進行比較：
func equal(x, y []string) bool {
if len(x) != len(y) {
return false
}
for i := range x {
if x[i] != y[i] {
return false
}
}
return true
}
上面關於兩個slice的深度相等測試，運行的時間並不比支持==操作的數組或字符串更多，但是為何slice不直接支持比較運算符呢？這方面有兩個原因。第一個原因，一個slice的元素是間接引用的，一個slice甚至可以包含自身（譯註：當slice聲明為[]interface{}時，slice的元素可以是自身）。雖然有很多辦法處理這種情形，但是沒有一個是簡單有效的。
第二個原因，因為slice的元素是間接引用的，一個固定的slice值（譯註：指slice本身的值，不是元素的值）在不同的時刻可能包含不同的元素，因為底層數組的元素可能會被修改。而例如Go語言中map的key只做簡單的淺拷貝，它要求key在整個生命週期內保持不變性（譯註：例如slice擴容，就會導致其本身的值/地址變化）。而用深度相等判斷的話，顯然在map的key這種場合不合適。對於像指針或chan之類的引用類型，==相等測試可以判斷兩個是否是引用相同的對象。一個針對slice的淺相等測試的==操作符可能是有一定用處的，也能臨時解決map類型的key問題，但是slice和數組不同的相等測試行為會讓人困惑。因此，安全的做法是直接禁止slice之間的比較操作。
slice唯一合法的比較操作是和nil比較，例如：
if summer == nil { /* ... */ }
一個零值的slice等於nil。一個nil值的slice並沒有底層數組。一個nil值的slice的長度和容量都是0，但是也有非nil值的slice的長度和容量也是0的，例如[]int{}或make([]int, 3)[3:]。與任意類型的nil值一樣，我們可以用[]int(nil)類型轉換表達式來生成一個對應類型slice的nil值。
var s []int // len(s) == 0, s == nil
s = nil // len(s) == 0, s == nil
s = []int(nil) // len(s) == 0, s == nil
s = []int{} // len(s) == 0, s != nil
如果你需要測試一個slice是否是空的，使用len(s) == 0來判斷，而不應該用s == nil來判斷。除了和nil相等比較外，一個nil值的slice的行為和其它任意0長度的slice一樣；例如reverse(nil)也是安全的。除了文檔已經明確說明的地方，所有的Go語言函數應該以相同的方式對待nil值的slice和0長度的slice。
內置的make函數創建一個指定元素類型、長度和容量的slice。容量部分可以省略，在這種情況下，容量將等於長度。
make([]T, len)
make([]T, len, cap) // same as make([]T, cap)[:len]
在底層，make創建了一個匿名的數組變量，然後返回一個slice；只有通過返回的slice才能引用底層匿名的數組變量。在第一種語句中，slice是整個數組的view。在第二個語句中，slice只引用了底層數組的前len個元素，但是容量將包含整個的數組。額外的元素是留給未來的增長用的。
4.2.1. append函數
內置的append函數用於向slice追加元素：
var runes []rune
for _, r := range "Hello, 世界" {
runes = append(runes, r)
}
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"
在循環中使用append函數構建一個由九個rune字符構成的slice，當然對應這個特殊的問題我們可以通過Go語言內置的[]rune("Hello, 世界")轉換操作完成。
append函數對於理解slice底層是如何工作的非常重要，所以讓我們仔細查看究竟是發生了什麼。下面是第一個版本的appendInt函數，專門用於處理[]int類型的slice：
gopl.io/ch4/append
func appendInt(x []int, y int) []int {
var z []int
zlen := len(x) + 1
if zlen <= cap(x) {
// There is room to grow. Extend the slice.
z = x[:zlen]
} else {
// There is insufficient space. Allocate a new array.
// Grow by doubling, for amortized linear complexity.
zcap := zlen
if zcap < 2*len(x) {
zcap = 2 * len(x)
}
z = make([]int, zlen, zcap)
copy(z, x) // a built-in function; see text
}
z[len(x)] = y
return z
}
每次調用appendInt函數，必須先檢測slice底層數組是否有足夠的容量來保存新添加的元素。如果有足夠空間的話，直接擴展slice（依然在原有的底層數組之上），將新添加的y元素複製到新擴展的空間，並返回slice。因此，輸入的x和輸出的z共享相同的底層數組。
如果沒有足夠的增長空間的話，appendInt函數則會先分配一個足夠大的slice用於保存新的結果，先將輸入的x複製到新的空間，然後添加y元素。結果z和輸入的x引用的將是不同的底層數組。
雖然通過循環複製元素更直接，不過內置的copy函數可以方便地將一個slice複製另一個相同類型的slice。copy函數的第一個參數是要複製的目標slice，第二個參數是源slice，目標和源的位置順序和dst = src賦值語句是一致的。兩個slice可以共享同一個底層數組，甚至有重疊也沒有問題。copy函數將返回成功複製的元素的個數（我們這裡沒有用到），等於兩個slice中較小的長度，所以我們不用擔心覆蓋會超出目標slice的範圍。
為了提高內存使用效率，新分配的數組一般略大於保存x和y所需要的最低大小。通過在每次擴展數組時直接將長度翻倍從而避免了多次內存分配，也確保了添加單個元素操作的平均時間是一個常數時間。這個程序演示了效果：
func main() {
var x, y []int
for i := 0; i < 10; i++ {
y = appendInt(x, i)
fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
x = y
}
}
每一次容量的變化都會導致重新分配內存和copy操作：
0 cap=1 [0]
1 cap=2 [0 1]
2 cap=4 [0 1 2]
3 cap=4 [0 1 2 3]
4 cap=8 [0 1 2 3 4]
5 cap=8 [0 1 2 3 4 5]
6 cap=8 [0 1 2 3 4 5 6]
7 cap=8 [0 1 2 3 4 5 6 7]
8 cap=16 [0 1 2 3 4 5 6 7 8]
9 cap=16 [0 1 2 3 4 5 6 7 8 9]
讓我們仔細查看i=3次的迭代。當時x包含了[0 1 2]三個元素，但是容量是4，因此可以簡單將新的元素添加到末尾，不需要新的內存分配。然後新的y的長度和容量都是4，並且和x引用著相同的底層數組，如圖4.2所示。
在下一次迭代時i=4，現在沒有新的空餘的空間了，因此appendInt函數分配一個容量為8的底層數組，將x的4個元素[0 1 2 3]複製到新空間的開頭，然後添加新的元素i，新元素的值是4。新的y的長度是5，容量是8；後面有3個空閒的位置，三次迭代都不需要分配新的空間。當前迭代中，y和x是對應不同底層數組的view。這次操作如圖4.3所示。
內置的append函數可能使用比appendInt更復雜的內存擴展策略。因此，通常我們並不知道append調用是否導致了內存的重新分配，因此我們也不能確認新的slice和原始的slice是否引用的是相同的底層數組空間。同樣，我們不能確認在原先的slice上的操作是否會影響到新的slice。因此，通常是將append返回的結果直接賦值給輸入的slice變量：
runes = append(runes, r)
更新slice變量不僅對調用append函數是必要的，實際上對應任何可能導致長度、容量或底層數組變化的操作都是必要的。要正確地使用slice，需要記住儘管底層數組的元素是間接訪問的，但是slice對應結構體本身的指針、長度和容量部分是直接訪問的。要更新這些信息需要像上面例子那樣一個顯式的賦值操作。從這個角度看，slice並不是一個純粹的引用類型，它實際上是一個類似下面結構體的聚合類型：
type IntSlice struct {
ptr *int
len, cap int
}
我們的appendInt函數每次只能向slice追加一個元素，但是內置的append函數則可以追加多個元素，甚至追加一個slice。
var x []int
x = append(x, 1)
x = append(x, 2, 3)
x = append(x, 4, 5, 6)
x = append(x, x...) // append the slice x
fmt.Println(x) // "[1 2 3 4 5 6 1 2 3 4 5 6]"
通過下面的小修改，我們可以達到append函數類似的功能。其中在appendInt函數參數中的最後的“...”省略號表示接收變長的參數為slice。我們將在5.7節詳細解釋這個特性。
func appendInt(x []int, y ...int) []int {
var z []int
zlen := len(x) + len(y)
// ...expand z to at least zlen...
copy(z[len(x):], y)
return z
}
為了避免重複，和前面相同的代碼並沒有顯示。
4.2.2. Slice內存技巧
讓我們看看更多的例子，比如旋轉slice、反轉slice或在slice原有內存空間修改元素。給定一個字符串列表，下面的nonempty函數將在原有slice內存空間之上返回不包含空字符串的列表：
gopl.io/ch4/nonempty
// Nonempty is an example of an in-place slice algorithm.
package main
import "fmt"
// nonempty returns a slice holding only the non-empty strings.
// The underlying array is modified during the call.
func nonempty(strings []string) []string {
i := 0
for _, s := range strings {
if s != "" {
strings[i] = s
i++
}
}
return strings[:i]
}
比較微妙的地方是，輸入的slice和輸出的slice共享一個底層數組。這可以避免分配另一個數組，不過原來的數據將可能會被覆蓋，正如下面兩個打印語句看到的那樣：
data := []string{"one", "", "three"}
fmt.Printf("%q\n", nonempty(data)) // `["one" "three"]`
fmt.Printf("%q\n", data) // `["one" "three" "three"]`
因此我們通常會這樣使用nonempty函數：data = nonempty(data)。
nonempty函數也可以使用append函數實現：
func nonempty2(strings []string) []string {
out := strings[:0] // zero-length slice of original
for _, s := range strings {
if s != "" {
out = append(out, s)
}
}
return out
}
無論如何實現，以這種方式重用一個slice一般都要求最多為每個輸入值產生一個輸出值，事實上很多這類算法都是用來過濾或合併序列中相鄰的元素。這種slice用法是比較複雜的技巧，雖然使用到了slice的一些技巧，但是對於某些場合是比較清晰和有效的。
一個slice可以用來模擬一個stack。最初給定的空slice對應一個空的stack，然後可以使用append函數將新的值壓入stack：
stack = append(stack, v) // push v
stack的頂部位置對應slice的最後一個元素：
top := stack[len(stack)-1] // top of stack
通過收縮stack可以彈出棧頂的元素
stack = stack[:len(stack)-1] // pop
要刪除slice中間的某個元素並保存原有的元素順序，可以通過內置的copy函數將後面的子slice向前依次移動一位完成：
func remove(slice []int, i int) []int {
copy(slice[i:], slice[i+1:])
return slice[:len(slice)-1]
}
func main() {
s := []int{5, 6, 7, 8, 9}
fmt.Println(remove(s, 2)) // "[5 6 8 9]"
}
如果刪除元素後不用保持原來順序的話，我們可以簡單的用最後一個元素覆蓋被刪除的元素：
func remove(slice []int, i int) []int {
slice[i] = slice[len(slice)-1]
return slice[:len(slice)-1]
}
func main() {
s := []int{5, 6, 7, 8, 9}
fmt.Println(remove(s, 2)) // "[5 6 9 8]
}
練習 4.3： 重寫reverse函數，使用數組指針代替slice。
練習 4.4： 編寫一個rotate函數，通過一次循環完成旋轉。
練習 4.5： 寫一個函數在原地完成消除[]string中相鄰重複的字符串的操作。
練習 4.6： 編寫一個函數，原地將一個UTF-8編碼的[]byte類型的slice中相鄰的空格（參考unicode.IsSpace）替換成一個空格返回
練習 4.7： 修改reverse函數用於原地反轉UTF-8編碼的[]byte。是否可以不用分配額外的內存？