共计 4442 个字符，预计需要花费 12 分钟才能阅读完成。
最近在油管下面看了一个视频：Understanding nil，挺有意思，这篇文章就对视频做一个演绎总结，代码示例都是来自于视频。
nil 是什么
置信写过 Golang 的程序员对上面一段代码是十分十分相熟的了：
if err != nil {// do something....}
当呈现不等于 nil 的时候，阐明呈现某些谬误了，须要咱们对这个谬误进行一些解决，而如果等于 nil 阐明运行失常。那什么是 nil 呢？查一下词典能够晓得，nil的意思是无，或者是零值。零值，zero value，是不是有点相熟？在 Go 语言中，如果你申明了一个变量然而没有对它进行赋值操作，那么这个变量就会有一个类型的默认零值。这是每种类型对应的零值：
bool -> false
numbers -> 0
string -> ""
pointers -> nil
slices -> nil
maps -> nil
channels -> nil
functions -> nil
interfaces -> nil
举个例子，当你定义了一个 struct：
type Person struct {
AgeYears int
Name string
Friends []Person}
var p Person // Person{0, "", nil}
变量 p 只申明但没有赋值，所以 p 的所有字段都有对应的零值。那么，这个 nil 到底是什么呢？Go 的文档中说到，_nil 是预约义的标识符，代表指针、通道、函数、接口、映射或切片的零值_，也就是预约义好的一个变量：
type Type int
var nil Type
是不是有点诧异？nil并不是 Go 的关键字之一，你甚至能够本人去扭转 nil 的值：
var nil = errors.New("hi")
这样是齐全能够编译得过的，然而最好不要这样子去做。
nil 有什么用
在理解了什么是 nil 之后，再来说说 nil 有什么用。
pointers
var p *int
p == nil // true
*p // panic: invalid memory address or nil pointer dereference
指针示意指向内存的地址，如果对为 nil 的指针进行解援用的话就会导致 panic。那么为 nil 的指针有什么用呢？先来看一个计算二叉树和的例子：
type tree struct {
v int
l *tree
r *tree
}
// first solution
func (t *tree) Sum() int {
sum := t.v
if t.l != nil {sum += t.l.Sum()
}
if t.r != nil {sum += t.r.Sum()
}
return sum
}
下面的代码有两个问题，一个是代码反复：
if v != nil {v.m()
}
另一个是当 t 是nil的时候会 panic：
var t *tree
sum := t.Sum() // panic: invalid memory address or nil pointer dereference怎么解决下面的问题？咱们先来看看一个指针接收器的例子：
type person struct {}
func sayHi(p *person) {fmt.Println("hi")
}
func (p *person) sayHi() {fmt.Println("hi")
}
var p *person
p.sayHi() // hi
对于指针对象的办法来说，就算指针的值为 nil 也是能够调用的，基于此，咱们能够对刚刚计算二叉树和的例子进行一下革新：
func(t *tree) Sum() int {
if t == nil {return 0}
return t.v + t.l.Sum() + t.r.Sum()
}
跟方才的代码一比照是不是简洁了很多？对于 nil 指针，只须要在办法后面判断一下就 ok 了，无需反复判断。换成打印二叉树的值或者查找二叉树的某个值都是一样的：
func(t *tree) String() string {
if t == nil {return ""}
return fmt.Sprint(t.l, t.v, t.r)
}
// nil receivers are useful: Find
func (t *tree) Find(v int) bool {
if t == nil {return false}
return t.v == v || t.l.Find(v) || t.r.Find(v)
}
所以如果不是很需要的话，不要用 NewX()去初始化值，而是应用它们的默认值。
slices
// nil slices
var s []slice
len(s) // 0
cap(s) // 0
for range s // iterates zero times
s[i] // panic: index out of range
一个为 nil 的 slice，除了不能索引外，其余的操作都是能够的，当你须要填充值的时候能够应用 append 函数，slice 会主动进行裁减。那么为 nil 的 slice 的底层构造是怎么的呢？依据官网的文档，slice 有三个元素，别离是长度、容量、指向数组的指针：
slice
当有元素的时候：
slice
所以咱们并不需要放心 slice 的大小，应用 append 的话 slice 会主动扩容。（视频中说 slice 主动扩容速度很快，不用放心性能问题，这个值得商讨，在确定 slice 大小的状况只进行一次内存调配总是好的）
map
对于 Go 来说，map，function，channel 都是非凡的指针，指向各自特定的实现，这个咱们临时能够不必管。
// nil map
var m map[t]u
len(m) // 0
for range m // iterates zero times
v, ok := m[i] // zero(u), false
m[i] = x // panic: assignment to entry in nil map
对于 nil 的 map，咱们能够简略把它看成是一个只读的 map，不能进行写操作，否则就会 panic。那么 nil 的 map 有什么用呢？看一下这个例子：
func NewGet(url string, headers map[string]string) (*http.Request, error) {req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {return nil, err}
for k, v := range headers {req.Header.Set(k, v)
}
return req, nil
}
对于 NewGet 来说，咱们须要传入一个类型为 map 的参数，并且这个函数只是对这个参数进行读取，咱们能够传入一个非空的值：
NewGet("http://google.com", map[string]string{"USER_AGENT": "golang/gopher",},)
或者这样传：
NewGet("http://google.com", map[string]string{})
然而后面也说了，map 的零值是 nil，所以当header 为空的时候，咱们也能够间接传入一个nil：
NewGet("http://google.com", nil)
是不是简洁很多？所以，把nil map 作为一个只读的空的 map 进行读取吧。
channel
// nil channels
var c chan
t<- c // blocks forever
c <- x // blocks forever
close(c) // panic: close of nil channel
敞开一个 nil 的 channel 会导致程序panic（如何敞开 channel 能够看这篇文章：如何优雅地敞开 Go channel）举个例子，如果当初有两个 channel 负责输出，一个 channel 负责汇总，简略的实现代码：
func merge(out chan<- int, a, b <-chan int) {
for {
select {
case v := <-a:
out <- v
case v := <- b:
out <- v
}
}
}
如果在内部调用中敞开了 a 或者 b，那么就会一直地从 a 或者 b 中读出 0，这和咱们想要的不一样，咱们想敞开 a 和 b 后就进行汇总了，批改一下代码：
func merge(out chan<- int, a, b <-chan int) {
for a != nil || b != nil {
select {
case v, ok := <-a:
if !ok {
a = nil
fmt.Println("a is nil")
continue
}
out <- v
case v, ok := <-b:
if !ok {
b = nil
fmt.Println("b is nil")
continue
}
out <- v
}
}
fmt.Println("close out")
close(out)
}
在晓得 channel 敞开后，将 channel 的值设为 nil，这样子就相当于将这个 select case 子句停用了，因为 nil 的 channel 是永远阻塞的。
interface
interface 并不是一个指针，它的底层实现由两局部组成，一个是类型，一个值，也就是相似于：(Type, Value)。只有当类型和值都是 nil 的时候，才等于nil。看看上面的代码：
func do() error { // error(*doError, nil)
var err *doError
return err // nil of type *doError
}
func main() {err := do()
fmt.Println(err == nil)
}
输入后果是 false。do 函数申明了一个 *doErro 的变量 err，而后返回，返回值是error 接口，然而这个时候的 Type 曾经变成了：（*doError，nil），所以和 nil 必定是不会相等的。所以咱们在写函数的时候，不要申明具体的 error 变量，而是应该间接返回nil：
func do() error { return nil}
再来看看这个例子：
func do() *doError { // nil of type *doError
return nil
}
func wrapDo() error { // error (*doError, nil)
return do() // nil of type *doError}
func main() {err := wrapDo() // error (*doError, nil)
fmt.Println(err == nil) // false
}
这里最终的输入后果也是 false。为什么呢？只管wrapDo 函数返回的是 error 类型，然而 do 返回的却是 *doError 类型，也就是变成了（*doError，nil），天然也就和 nil 不相等了。因而，不要返回具体的谬误类型。听从这两条倡议，才能够释怀地应用if x != nil。
总结
看完了那个视频，发现 nil 还有这么多用处，真是意外之喜。
油管下面还有很多干货满满的视频，能够多学习学习咯。