切片 slice 原理分析 前言 示例 slice 原理 總結

前言

作爲一個 Go 語言新手，看到一切”詭異“的代碼都會感到好奇；比如我最近看到的幾個方法；僞代碼如下：

func FindA() ([]*T,error) {
}

func FindB() ([]T,error) {
}

func SaveA(data *[]T) error {
}

func SaveB(data *[]*T) error {
}

相信大部分剛入門 Go 的新手看到這樣的代碼也是一臉懵逼，其中最讓人疑惑的就是：

[]*T
*[]T
*[]*T

這樣對切片的聲明，先不看後面兩種寫法；單獨看 []*T 還是很好理解的：
該切片中存放的是所有 T 的內存地址，會比存放 T 本身來說要更省空間，同時 []*T 在方法內部是可以修改 T 的值，而[]T 是修改不了。

func TestSaveSlice(t *testing.T) {
    a := []T{{Name: "1"}, {Name: "2"}}
    for _, t2 := range a {
        fmt.Println(t2)
    }
    _ = SaveB(a)
    for _, t2 := range a {
        fmt.Println(t2)
    }

}
func SaveB(data []T) error {
    t := data[0]
    t.Name = "1233"
    return nil
}

type T struct {
    Name string
}

比如以上例子打印的是

{1}
{2}
{1}
{2}

只有將方法修改爲

func SaveB(data []*T) error {
    t := data[0]
    t.Name = "1233"
    return nil
}

才能修改 T 的值:

&{1}
&{2}
&{1233}
&{2}

示例

下面重點來看看 []*T 與 *[]T 的區別，這裏寫了兩個 append 函數：

func TestAppendA(t *testing.T) {
    x:=[]int{1,2,3}
    appendA(x)
    fmt.Printf("main %v\n", x)
}
func appendA(x []int) {
    x[0]= 100
    fmt.Printf("appendA %v\n", x)
}

先看第一種，輸出是結果是：

appendA [1000 2 3]
main [1000 2 3]

說明在函數傳遞過程中，函數內部的修改能夠影響到外部。

---

下面我們再看一個例子：

func appendB(x []int) {
    x = append(x, 4)
    fmt.Printf("appendA %v\n", x)
}

最終結果卻是：

appendA [1 2 3 4]
main [1 2 3]

沒有影響到外部。

而當我們再調整一下會發現又有所不同：

func TestAppendC(t *testing.T) {
    x:=[]int{1,2,3}
    appendC(&x)
    fmt.Printf("main %v\n", x)
}
func appendC(x *[]int) {
    *x = append(*x, 4)
    fmt.Printf("appendA %v\n", x)
}

最終的結果：

appendA &[1 2 3 4]
main [1 2 3 4]

可以發現如果傳遞切片的指針時，使用 append 函數追加數據時會影響到外部。

slice 原理

在分析上面三種情況之前，我們先來了解下 slice 的數據結構。

直接查看源碼會發現 slice 其實就是一個結構體，只是不能直接對外訪問。

源碼地址 runtime/slice.go

其中有三個重要的屬性：

屬性	含義
array	底層存放數據的數組，是一個指針。
len	切片長度
cap	切片容量 cap>=len

提到切片就不得不想到數組，可以這麼理解：

切片是對數組的抽象，而數組則是切片的底層實現。

其實通過切片這個名字也不難看出，它就是從數組中切了一部分；相對於數組的固定大小，切片可以根據實際使用情況進行擴容。

所以切片也可以通過對數組"切一刀"獲得：

x1:=[6]int{0,1,2,3,4,5}
x2 := x[1:4]
fmt.Println(len(x2), cap(x2))

其中 x1 的長度與容量都是6。

x2 的長度與容量則爲3和5。

• x2 的長度很容易理解。
• 容量等於5可以理解爲，當前這個切片最多可以使用的長度。

因爲切片 x2 是對數組 x1 的引用，所以底層數組排除掉左邊一個沒有被引用的位置則是該切片最大的容量，也就是5。

同一個底層數組

以剛纔的代碼爲例：

func TestAppendA(t *testing.T) {
    x:=[]int{1,2,3}
    appendA(x)
    fmt.Printf("main %v\n", x)
}
func appendA(x []int) {
    x[0]= 100
    fmt.Printf("appendA %v\n", x)
}

在函數傳遞過程中，main 中的 x 與 appendA 函數中的 x 切片所引用的是同個數組。

所以在函數中對 x[0]=100，main函數中也能獲取到。

本質上修改的就是同一塊內存數據。

值傳遞帶來的誤會

在上述例子中，在 appendB 中調用 append 函數追加數據後會發現 main 函數中並沒有受到影響，這裏我稍微調整了一下示例代碼：

func TestAppendB(t *testing.T) {
    //x:=[]int{1,2,3}
    x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))
}
func appendB(x []int) {
    x = append(x, 444)
    fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x))
}

主要是修改了切片初始化方式，使得容量大於了長度，具體原因後續會說明。

輸出結果如下：

appendB [1 2 3 444] len=4,cap=5
main [1 2 3] len=3,cap=5

main 函數中的數據看樣子確實沒有受到影響；但細心的朋友應該會注意到 appendB 函數中的 x 在 append() 之後長度 +1 變爲了4。

而在 main 函數中長度又變回了3.

這個細節區別就是爲什麼 append() "看似" 沒有生效的原因；至於爲什麼要說“看似”，再次調整了代碼：

func TestAppendB(t *testing.T) {
    //x:=[]int{1,2,3}
    x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))

    y:=x[0:cap(x)]
    fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y))
}

在剛纔的基礎之上，以 append 之後的 x 爲基礎再做了一個切片；該切片的範圍爲 x 所引用數組的全部數據。

再來看看執行結果如何：

appendB [1 2 3 444] len=4,cap=5
main [1 2 3] len=3,cap=5
y [1 2 3 444 0] len=5,cap=5

會神奇的發現 y 將所有數據都打印出來，在 appendB 函數中追加的數據其實已經寫入了數組中，但爲什麼 x 本身沒有獲取到呢？

看圖就很容易理解了：

• 在appendB中確實是對原始數組追加了數據，同時長度也增加了。
• 但由於是值傳遞，所以 slice 這個結構體即便是修改了長度爲4，也只是對複製的那個對象修改了長度，main 中的長度依然爲3.
• 由於底層數組是同一個，所以基於這個底層數組重新生成了一個完整長度的切片便能看到追加的數據了。

所以這裏本質的原因是因爲 slice 是一個結構體，傳遞的是值，不管方法裏如何修改長度也不會影響到原有的數據（這裏指的是長度和容量這兩個屬性）。

切片擴容

還有一個需要注意：

剛纔特意提到這裏的例子稍有改變，主要是將切片的容量設置超過了數組的長度；

如果不做這個特殊設置會怎麼樣呢？

func TestAppendB(t *testing.T) {
    x:=[]int{1,2,3}
    //x := make([]int, 3,5)
    x[0] = 1
    x[1] = 2
    x[2] = 3
    appendB(x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))

    y:=x[0:cap(x)]
    fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y))
}
func appendB(x []int) {
    x = append(x, 444)
    fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x))
}

輸出結果：

appendB [1 2 3 444] len=4,cap=6
main [1 2 3] len=3,cap=3
y [1 2 3] len=3,cap=3

這時會發現 main 函數中的 y 切片數據也沒有發生變化，這是爲什麼呢？

這是因爲初始化 x 切片時長度和容量都爲3，當在 appendB 函數中追加數據時，會發現沒有位置了。

這時便會進行擴容：

• 將老數據複製一份到新的數組中。
• 追加數據。
• 將新的數據內存地址返回給 appendB 中的 x .

同樣的由於是值傳遞，所以 appendB 中的切片換了底層數組對 main 函數中的切片沒有任何影響，也就導致最終 main 函數的數據沒有任何變化了。

傳遞切片指針

有沒有什麼辦法即便是在擴容時也能對外部產生影響呢？

func TestAppendC(t *testing.T) {
    x:=[]int{1,2,3}
    appendC(&x)
    fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x))
}
func appendC(x *[]int) {
    *x = append(*x, 4)
    fmt.Printf("appendC %v\n", x)
}

輸出結果爲：

appendC &[1 2 3 4]
main [1 2 3 4] len=4,cap=6

這時外部的切片就能受到影響了，其實原因也很簡單；

剛纔也說了，因爲 slice 本身是一個結構體，所以當我們傳遞指針時，就和平時自定義的 struct 在函數內部通過指針修改數據原理相同。

最終在 appendC 中的 x 的指針指向了擴容後的結構體，因爲傳遞的是 main 函數中 x 的指針，所以同樣的 main 函數中的 x 也指向了該結構體。

總結

所以總結一下：

• 切片是對數組的抽象，同時切片本身也是一個結構體。
• 參數傳遞時函數內部與外部引用的是同一個數組，所以對切片的修改會影響到函數外部。
• 如果發生擴容，情況會發生變化，同時擴容會導致數據拷貝；所以要儘量預估切片大小，避免數據拷貝。
• 對切片或數組重新生成切片時，由於共享的是同一個底層數組，所以數據會互相影響，這點需要注意。
• 切片也可以傳遞指針，但場景很少，還會帶來不必要的誤解；建議值傳值就好，長度和容量佔用不了多少內存。

相信使用過切片會發現非常類似於 Java 中的 ArrayList，同樣是基於數組實現，也會擴容發生數據拷貝；這樣看來語言只是上層使用的選擇，一些通用的底層實現大家都差不多。

這時我們再看標題中的 []*T *[]T *[]*T 就會發現這幾個並沒有什麼聯繫，只是看起來很像容易唬人。