[转]理解Go语言中的nil

最近在油管上面看了一个视频：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，channel都是特殊的指针，指向各自特定的实现，这个咱们暂时能够不用管。

// nil maps 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还有这么多用处，真是意外之喜。
油管上面还有不少干货满满的视频，能够多学习学习咯。

参考

https://www.jianshu.com/p/dd80f6be7969