Go 語言切片的三種特殊狀態 —— 90% 的開發者都忽視了

我們今天要來講一個非常細節的小知識，這個知識被大多數 Go 語言的開發者無視了，它就是切片的三種特殊狀態 —— 「零切片」、「空切片」和「nil 切片」。

切片被視為 Go 語言中最為重要的基礎資料結構，使用起來非常簡單，有趣的內部結構讓它成了 Go 語言面試中最為常見的考點。切片的底層是一個陣列，切片的表層是一個包含三個變數的結構體，當我們將一個切片賦值給另一個切片時，本質上是對切片表層結構體的淺複製。結構體中第一個變數是一個指標，指向底層的陣列，另外兩個變數分別是切片的長度和容量。

type slice struct {
  array unsafe.Pointer
  length int
  capcity int
}

我們今天要講的特殊狀態之一「零切片」其實並不是什麼特殊的切片，它只是表示底層陣列的二進位制內容都是零。比如下面程式碼中的 s 變數就是一個「零切片」

var s = make([]int, 10)
fmt.Println(s)
------------
[0 0 0 0 0 0 0 0 0 0]

如果是一個指標型別的切片，那麼底層陣列的內容就全是 nil

var s = make([]*int, 10)
fmt.Println(s)
------------
[<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil>]

零切片還是比較易於理解的，這部分我也就不再以鑽牛角尖的形式繼續自我拷問。

下面我們要引入「空切片」和 「nil 切片」，在理解它們的區別之前我們先看看一個長度為零的切片都有那些形式可以建立出來

var s1 []int
var s2 = []int{}
var s3 = make([]int, 0)
// new 函式返回是指標型別，所以需要使用 * 號來解引用
var s4 = *new([]int)

fmt.Println(len(s1), len(s2), len(s3), len(s4))
fmt.Println(cap(s1), cap(s2), cap(s3), cap(s4))
fmt.Println(s1, s2, s3, s4)

----------------
0 0 0 0
0 0 0 0
[] [] [] []

上面這四種形式從輸出結果上來看，似乎一摸一樣，沒區別。但是實際上是有區別的，我們要講的兩種特殊型別「空切片」和「 nil 切片」，就隱藏在上面的四種形式之中。

我們如何來分析三面四種形式的內部結構的區別呢？接下里要使用到 Go 語言的高階內容，透過 unsafe.Pointer 來轉換 Go 語言的任意變數型別。

因為切片的內部結構是一個結構體，包含三個機器字大小的整型變數，其中第一個變數是一個指標變數，指標變數裡面儲存的也是一個整型值，只不過這個值是另一個變數的記憶體地址。我們可以將這個結構體看成長度為 3 的整型陣列 [3]int。然後將切片變數轉換成 [3]int。

var s1 []int
var s2 = []int{}
var s3 = make([]int, 0)
var s4 = *new([]int)

var a1 = *(*[3]int)(unsafe.Pointer(&s1))
var a2 = *(*[3]int)(unsafe.Pointer(&s2))
var a3 = *(*[3]int)(unsafe.Pointer(&s3))
var a4 = *(*[3]int)(unsafe.Pointer(&s4))
fmt.Println(a1)
fmt.Println(a2)
fmt.Println(a3)
fmt.Println(a4)

---------------------
[0 0 0]
[824634199592 0 0]
[824634199592 0 0]
[0 0 0]

從輸出中我們看到了明顯的神奇的讓人感到意外的難以理解的不一樣的結果。如果上面的 unsafe 程式碼你不能理解，那就繼續等等我的《快學 Go 語言》章節的更新吧。

其中輸出為 [0 0 0] 的 s1 和 s4 變數就是「 nil 切片」，s2 和 s3 變數就是「空切片」。824634199592 這個值是一個特殊的記憶體地址，所有型別的「空切片」都共享這一個記憶體地址。下面的程式碼中三個空切片都指向了同一個記憶體地址。

var s2 = []int{}
var s3 = make([]int, 0)

var a2 = *(*[3]int)(unsafe.Pointer(&s2))
var a3 = *(*[3]int)(unsafe.Pointer(&s3))
fmt.Println(a2)
fmt.Println(a3)

var s5 = make([]struct{ x, y, z int }, 0)
var a5 = *(*[3]int)(unsafe.Pointer(&s5))
fmt.Println(a5)

--------
[824634158720 0 0]
[824634158720 0 0]
[824634158720 0 0]

用圖形來表示「空切片」和「 nil 切片」如下

空切片指向的 zerobase 記憶體地址是一個神奇的地址，從 Go 語言的原始碼中可以看到它的定義

//// runtime/malloc.go

// base address for all 0-byte allocations
var zerobase uintptr

// 分配物件記憶體
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    ...
    if size == 0 {
        return unsafe.Pointer(&zerobase)
    }
    ...
}

//// runtime/slice.go
// 建立切片
func makeslice(et *_type, len, cap int) slice {
     ...
     p := mallocgc(et.size*uintptr(cap), et, true)
     return slice{p, len, cap}
}

最後一個問題是：「 nil 切片」和 「空切片」在使用上有什麼區別麼？

答案是完全沒有任何區別！No！不對，還有一個小小的區別！請看下面的程式碼

package main

import "fmt"

func main() {
    var s1 []int
    var s2 = []int{}

    fmt.Println(s1 == nil)
    fmt.Println(s2 == nil)

    fmt.Printf("%#v\n", s1)
    fmt.Printf("%#v\n", s2)
}

-------
true
false
[]int(nil)
[]int{}

所以為了避免寫程式碼的時候把腦袋搞昏的最好辦法是不要建立「 空切片」，統一使用「 nil 切片」，同時要避免將切片和 nil 進行比較來執行某些邏輯。這是官方的標準建議。

The former declares a nil slice value, while the latter is non-nil but zero-length. They are functionally equivalent—their len and cap are both zero—but the nil slice is the preferred style.

「空切片」和「 nil 切片」有時候會隱藏在結構體中，這時候它們的區別就被太多的人忽略了，下面我們看個例子

type Something struct {
    values []int
}

var s1 = Something{}
var s2 = Something{[]int{}}
fmt.Println(s1.values == nil)
fmt.Println(s2.values == nil)

--------
true
false

可以發現這兩種建立結構體的結果是不一樣的！第一種無參構造建立了 nil 切片，而第二種則建立了空切片。

「空切片」和「 nil 切片」還有一個極為不同的地方在於 JSON 序列化

type Something struct {
    Values []int
}

var s1 = Something{}
var s2 = Something{[]int{}}
bs1, _ := json.Marshal(s1)
bs2, _ := json.Marshal(s2)
fmt.Println(string(bs1))
fmt.Println(string(bs2))

---------
{"Values":null}
{"Values":[]}

Ban! Ban! Ban! 它們的 json 序列化結果居然也不一樣！