Go 語(yǔ)言 Slice

原文鏈接：https://gopl-zh.github.io/ch4/ch4-02.html

4.2. Slice

Slice（切片）代表變長(zhǎng)的序列，序列中每個(gè)元素都有相同的類型。一個(gè)slice類型一般寫作[]T，其中T代表slice中元素的類型；slice的語(yǔ)法和數(shù)組很像，只是沒(méi)有固定長(zhǎng)度而已。

數(shù)組和slice之間有著緊密的聯(lián)系。一個(gè)slice是一個(gè)輕量級(jí)的數(shù)據(jù)結(jié)構(gòu)，提供了訪問(wèn)數(shù)組子序列（或者全部）元素的功能，而且slice的底層確實(shí)引用一個(gè)數(shù)組對(duì)象。一個(gè)slice由三個(gè)部分構(gòu)成：指針、長(zhǎng)度和容量。指針指向第一個(gè)slice元素對(duì)應(yīng)的底層數(shù)組元素的地址，要注意的是slice的第一個(gè)元素并不一定就是數(shù)組的第一個(gè)元素。長(zhǎng)度對(duì)應(yīng)slice中元素的數(shù)目；長(zhǎng)度不能超過(guò)容量，容量一般是從slice的開(kāi)始位置到底層數(shù)據(jù)的結(jié)尾位置。內(nèi)置的len和cap函數(shù)分別返回slice的長(zhǎng)度和容量。

多個(gè)slice之間可以共享底層的數(shù)據(jù)，并且引用的數(shù)組部分區(qū)間可能重疊。圖4.1顯示了表示一年中每個(gè)月份名字的字符串?dāng)?shù)組，還有重疊引用了該數(shù)組的兩個(gè)slice。數(shù)組這樣定義

months := [...]string{1: "January", /* ... */, 12: "December"}

因此一月份是months[1]，十二月份是months[12]。通常，數(shù)組的第一個(gè)元素從索引0開(kāi)始，但是月份一般是從1開(kāi)始的，因此我們聲明數(shù)組時(shí)直接跳過(guò)第0個(gè)元素，第0個(gè)元素會(huì)被自動(dòng)初始化為空字符串。

slice的切片操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用于創(chuàng)建一個(gè)新的slice，引用s的從第i個(gè)元素開(kāi)始到第j-1個(gè)元素的子序列。新的slice將只有j-i個(gè)元素。如果i位置的索引被省略的話將使用0代替，如果j位置的索引被省略的話將使用len(s)代替。因此，months[1:13]切片操作將引用全部有效的月份，和months[1:]操作等價(jià)；months[:]切片操作則是引用整個(gè)數(shù)組。讓我們分別定義表示第二季度和北方夏天月份的slice，它們有重疊部分：

Q2 := months[4:7]
summer := months[6:9]
fmt.Println(Q2)     // ["April" "May" "June"]
fmt.Println(summer) // ["June" "July" "August"]

兩個(gè)slice都包含了六月份，下面的代碼是一個(gè)包含相同月份的測(cè)試（性能較低）：

for _, s := range summer {
    for _, q := range Q2 {
        if s == q {
            fmt.Printf("%s appears in both\n", s)
        }
    }
}

如果切片操作超出cap(s)的上限將導(dǎo)致一個(gè)panic異常，但是超出len(s)則是意味著擴(kuò)展了slice，因?yàn)樾聅lice的長(zhǎng)度會(huì)變大：

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字節(jié)類型切片的切片操作是類似的。都寫作x[m:n]，并且都是返回一個(gè)原始字節(jié)序列的子序列，底層都是共享之前的底層數(shù)組，因此這種操作都是常量時(shí)間復(fù)雜度。x[m:n]切片操作對(duì)于字符串則生成一個(gè)新字符串，如果x是[]byte的話則生成一個(gè)新的[]byte。

因?yàn)閟lice值包含指向第一個(gè)slice元素的指針，因此向函數(shù)傳遞slice將允許在函數(shù)內(nèi)部修改底層數(shù)組的元素。換句話說(shuō)，復(fù)制一個(gè)slice只是對(duì)底層的數(shù)組創(chuàng)建了一個(gè)新的slice別名（§2.3.2）。下面的reverse函數(shù)在原內(nèi)存空間將[]int類型的slice反轉(zhuǎn)，而且它可以用于任意長(zhǎng)度的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]
    }
}

這里我們反轉(zhuǎn)數(shù)組的應(yīng)用：

a := [...]int{0, 1, 2, 3, 4, 5}
reverse(a[:])
fmt.Println(a) // "[5 4 3 2 1 0]"

一種將slice元素循環(huán)向左旋轉(zhuǎn)n個(gè)元素的方法是三次調(diào)用reverse反轉(zhuǎn)函數(shù)，第一次是反轉(zhuǎn)開(kāi)頭的n個(gè)元素，然后是反轉(zhuǎn)剩下的元素，最后是反轉(zhuǎn)整個(gè)slice的元素。（如果是向右循環(huán)旋轉(zhuǎn)，則將第三個(gè)函數(shù)調(diào)用移到第一個(gè)調(diào)用位置就可以了。）

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和數(shù)組類型的變量a的初始化語(yǔ)法的差異。slice和數(shù)組的字面值語(yǔ)法很類似，它們都是用花括弧包含一系列的初始化元素，但是對(duì)于slice并沒(méi)有指明序列的長(zhǎng)度。這會(huì)隱式地創(chuàng)建一個(gè)合適大小的數(shù)組，然后slice的指針指向底層的數(shù)組。就像數(shù)組字面值一樣，slice的字面值也可以按順序指定初始化值序列，或者是通過(guò)索引和元素值指定，或者用兩種風(fēng)格的混合語(yǔ)法初始化。

和數(shù)組不同的是，slice之間不能比較，因此我們不能使用==操作符來(lái)判斷兩個(gè)slice是否含有全部相等元素。不過(guò)標(biāo)準(zhǔn)庫(kù)提供了高度優(yōu)化的bytes.Equal函數(shù)來(lái)判斷兩個(gè)字節(jié)型slice是否相等（[]byte），但是對(duì)于其他類型的slice，我們必須自己展開(kāi)每個(gè)元素進(jìn)行比較：

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
}

上面關(guān)于兩個(gè)slice的深度相等測(cè)試，運(yùn)行的時(shí)間并不比支持==操作的數(shù)組或字符串更多，但是為何slice不直接支持比較運(yùn)算符呢？這方面有兩個(gè)原因。第一個(gè)原因，一個(gè)slice的元素是間接引用的，一個(gè)slice甚至可以包含自身（譯注：當(dāng)slice聲明為[]interface{}時(shí)，slice的元素可以是自身）。雖然有很多辦法處理這種情形，但是沒(méi)有一個(gè)是簡(jiǎn)單有效的。

第二個(gè)原因，因?yàn)閟lice的元素是間接引用的，一個(gè)固定的slice值（譯注：指slice本身的值，不是元素的值）在不同的時(shí)刻可能包含不同的元素，因?yàn)榈讓訑?shù)組的元素可能會(huì)被修改。而例如Go語(yǔ)言中map的key只做簡(jiǎn)單的淺拷貝，它要求key在整個(gè)生命周期內(nèi)保持不變性（譯注：例如slice擴(kuò)容，就會(huì)導(dǎo)致其本身的值/地址變化）。而用深度相等判斷的話，顯然在map的key這種場(chǎng)合不合適。對(duì)于像指針或chan之類的引用類型，==相等測(cè)試可以判斷兩個(gè)是否是引用相同的對(duì)象。一個(gè)針對(duì)slice的淺相等測(cè)試的==操作符可能是有一定用處的，也能臨時(shí)解決map類型的key問(wèn)題，但是slice和數(shù)組不同的相等測(cè)試行為會(huì)讓人困惑。因此，安全的做法是直接禁止slice之間的比較操作。

slice唯一合法的比較操作是和nil比較，例如：

if summer == nil { /* ... */ }

一個(gè)零值的slice等于nil。一個(gè)nil值的slice并沒(méi)有底層數(shù)組。一個(gè)nil值的slice的長(zhǎng)度和容量都是0，但是也有非nil值的slice的長(zhǎng)度和容量也是0的，例如[]int{}或make([]int, 3)[3:]。與任意類型的nil值一樣，我們可以用[]int(nil)類型轉(zhuǎn)換表達(dá)式來(lái)生成一個(gè)對(duì)應(yīng)類型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

如果你需要測(cè)試一個(gè)slice是否是空的，使用len(s) == 0來(lái)判斷，而不應(yīng)該用s == nil來(lái)判斷。除了和nil相等比較外，一個(gè)nil值的slice的行為和其它任意0長(zhǎng)度的slice一樣；例如reverse(nil)也是安全的。除了文檔已經(jīng)明確說(shuō)明的地方，所有的Go語(yǔ)言函數(shù)應(yīng)該以相同的方式對(duì)待nil值的slice和0長(zhǎng)度的slice。

內(nèi)置的make函數(shù)創(chuàng)建一個(gè)指定元素類型、長(zhǎng)度和容量的slice。容量部分可以省略，在這種情況下，容量將等于長(zhǎng)度。

make([]T, len)
make([]T, len, cap) // same as make([]T, cap)[:len]

在底層，make創(chuàng)建了一個(gè)匿名的數(shù)組變量，然后返回一個(gè)slice；只有通過(guò)返回的slice才能引用底層匿名的數(shù)組變量。在第一種語(yǔ)句中，slice是整個(gè)數(shù)組的view。在第二個(gè)語(yǔ)句中，slice只引用了底層數(shù)組的前l(fā)en個(gè)元素，但是容量將包含整個(gè)的數(shù)組。額外的元素是留給未來(lái)的增長(zhǎng)用的。

4.2.1. append函數(shù)

內(nèi)置的append函數(shù)用于向slice追加元素：

var runes []rune
for _, r := range "Hello, 世界" {
    runes = append(runes, r)
}
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"

在循環(huán)中使用append函數(shù)構(gòu)建一個(gè)由九個(gè)rune字符構(gòu)成的slice，當(dāng)然對(duì)應(yīng)這個(gè)特殊的問(wèn)題我們可以通過(guò)Go語(yǔ)言內(nèi)置的[]rune("Hello, 世界")轉(zhuǎn)換操作完成。

append函數(shù)對(duì)于理解slice底層是如何工作的非常重要，所以讓我們仔細(xì)查看究竟是發(fā)生了什么。下面是第一個(gè)版本的appendInt函數(shù)，專門用于處理[]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
}

每次調(diào)用appendInt函數(shù)，必須先檢測(cè)slice底層數(shù)組是否有足夠的容量來(lái)保存新添加的元素。如果有足夠空間的話，直接擴(kuò)展slice（依然在原有的底層數(shù)組之上），將新添加的y元素復(fù)制到新擴(kuò)展的空間，并返回slice。因此，輸入的x和輸出的z共享相同的底層數(shù)組。

如果沒(méi)有足夠的增長(zhǎng)空間的話，appendInt函數(shù)則會(huì)先分配一個(gè)足夠大的slice用于保存新的結(jié)果，先將輸入的x復(fù)制到新的空間，然后添加y元素。結(jié)果z和輸入的x引用的將是不同的底層數(shù)組。

雖然通過(guò)循環(huán)復(fù)制元素更直接，不過(guò)內(nèi)置的copy函數(shù)可以方便地將一個(gè)slice復(fù)制另一個(gè)相同類型的slice。copy函數(shù)的第一個(gè)參數(shù)是要復(fù)制的目標(biāo)slice，第二個(gè)參數(shù)是源slice，目標(biāo)和源的位置順序和dst = src賦值語(yǔ)句是一致的。兩個(gè)slice可以共享同一個(gè)底層數(shù)組，甚至有重疊也沒(méi)有問(wèn)題。copy函數(shù)將返回成功復(fù)制的元素的個(gè)數(shù)（我們這里沒(méi)有用到），等于兩個(gè)slice中較小的長(zhǎng)度，所以我們不用擔(dān)心覆蓋會(huì)超出目標(biāo)slice的范圍。

為了提高內(nèi)存使用效率，新分配的數(shù)組一般略大于保存x和y所需要的最低大小。通過(guò)在每次擴(kuò)展數(shù)組時(shí)直接將長(zhǎng)度翻倍從而避免了多次內(nèi)存分配，也確保了添加單個(gè)元素操作的平均時(shí)間是一個(gè)常數(shù)時(shí)間。這個(gè)程序演示了效果：

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
    }
}

每一次容量的變化都會(huì)導(dǎo)致重新分配內(nèi)存和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]

讓我們仔細(xì)查看i=3次的迭代。當(dāng)時(shí)x包含了[0 1 2]三個(gè)元素，但是容量是4，因此可以簡(jiǎn)單將新的元素添加到末尾，不需要新的內(nèi)存分配。然后新的y的長(zhǎng)度和容量都是4，并且和x引用著相同的底層數(shù)組，如圖4.2所示。

內(nèi)置的append函數(shù)可能使用比appendInt更復(fù)雜的內(nèi)存擴(kuò)展策略。因此，通常我們并不知道append調(diào)用是否導(dǎo)致了內(nèi)存的重新分配，因此我們也不能確認(rèn)新的slice和原始的slice是否引用的是相同的底層數(shù)組空間。同樣，我們不能確認(rèn)在原先的slice上的操作是否會(huì)影響到新的slice。因此，通常是將append返回的結(jié)果直接賦值給輸入的slice變量：

runes = append(runes, r)

更新slice變量不僅對(duì)調(diào)用append函數(shù)是必要的，實(shí)際上對(duì)應(yīng)任何可能導(dǎo)致長(zhǎng)度、容量或底層數(shù)組變化的操作都是必要的。要正確地使用slice，需要記住盡管底層數(shù)組的元素是間接訪問(wèn)的，但是slice對(duì)應(yīng)結(jié)構(gòu)體本身的指針、長(zhǎng)度和容量部分是直接訪問(wèn)的。要更新這些信息需要像上面例子那樣一個(gè)顯式的賦值操作。從這個(gè)角度看，slice并不是一個(gè)純粹的引用類型，它實(shí)際上是一個(gè)類似下面結(jié)構(gòu)體的聚合類型：

type IntSlice struct {
    ptr      *int
    len, cap int
}

我們的appendInt函數(shù)每次只能向slice追加一個(gè)元素，但是內(nèi)置的append函數(shù)則可以追加多個(gè)元素，甚至追加一個(gè)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]"

通過(guò)下面的小修改，我們可以達(dá)到append函數(shù)類似的功能。其中在appendInt函數(shù)參數(shù)中的最后的“...”省略號(hào)表示接收變長(zhǎng)的參數(shù)為slice。我們將在5.7節(jié)詳細(xì)解釋這個(gè)特性。

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
}

為了避免重復(fù)，和前面相同的代碼并沒(méi)有顯示。

4.2.2. Slice內(nèi)存技巧

讓我們看看更多的例子，比如旋轉(zhuǎn)slice、反轉(zhuǎn)slice或在slice原有內(nèi)存空間修改元素。給定一個(gè)字符串列表，下面的nonempty函數(shù)將在原有slice內(nèi)存空間之上返回不包含空字符串的列表：

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共享一個(gè)底層數(shù)組。這可以避免分配另一個(gè)數(shù)組，不過(guò)原來(lái)的數(shù)據(jù)將可能會(huì)被覆蓋，正如下面兩個(gè)打印語(yǔ)句看到的那樣：

data := []string{"one", "", "three"}
fmt.Printf("%q\n", nonempty(data)) // `["one" "three"]`
fmt.Printf("%q\n", data)           // `["one" "three" "three"]`

因此我們通常會(huì)這樣使用nonempty函數(shù)：data = nonempty(data)。

nonempty函數(shù)也可以使用append函數(shù)實(shí)現(xiàn)：

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
}

無(wú)論如何實(shí)現(xiàn)，以這種方式重用一個(gè)slice一般都要求最多為每個(gè)輸入值產(chǎn)生一個(gè)輸出值，事實(shí)上很多這類算法都是用來(lái)過(guò)濾或合并序列中相鄰的元素。這種slice用法是比較復(fù)雜的技巧，雖然使用到了slice的一些技巧，但是對(duì)于某些場(chǎng)合是比較清晰和有效的。

一個(gè)slice可以用來(lái)模擬一個(gè)stack。最初給定的空slice對(duì)應(yīng)一個(gè)空的stack，然后可以使用append函數(shù)將新的值壓入stack：

stack = append(stack, v) // push v

stack的頂部位置對(duì)應(yīng)slice的最后一個(gè)元素：

top := stack[len(stack)-1] // top of stack

通過(guò)收縮stack可以彈出棧頂?shù)脑?

stack = stack[:len(stack)-1] // pop

要?jiǎng)h除slice中間的某個(gè)元素并保存原有的元素順序，可以通過(guò)內(nèi)置的copy函數(shù)將后面的子slice向前依次移動(dòng)一位完成：

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]"
}

如果刪除元素后不用保持原來(lái)順序的話，我們可以簡(jiǎn)單的用最后一個(gè)元素覆蓋被刪除的元素：

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]
}

練習(xí) 4.3： 重寫reverse函數(shù)，使用數(shù)組指針代替slice。

練習(xí) 4.4： 編寫一個(gè)rotate函數(shù)，通過(guò)一次循環(huán)完成旋轉(zhuǎn)。

練習(xí) 4.5： 寫一個(gè)函數(shù)在原地完成消除[]string中相鄰重復(fù)的字符串的操作。

練習(xí) 4.6： 編寫一個(gè)函數(shù)，原地將一個(gè)UTF-8編碼的[]byte類型的slice中相鄰的空格（參考unicode.IsSpace）替換成一個(gè)空格返回

練習(xí) 4.7： 修改reverse函數(shù)用于原地反轉(zhuǎn)UTF-8編碼的[]byte。是否可以不用分配額外的內(nèi)存？