深度解析 Go 語言中「切片」的三種特殊狀態

咱們今天要來說一個很是細節的小知識，這個知識被大多數 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]
複製代碼

從輸出中咱們看到了明顯的神奇的讓人感到意外的難以理解的不同的結果。

其中輸出爲 [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 切片」還有一個極爲不一樣的地方在於 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 序列化結果竟然也不同！

掃一掃二維碼閱讀《快學 Go 語言》更多章節