深度解析 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 语言》更多章节