理解Go語言的nil

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

最近在油管上面看了一個視頻：Understanding nil，挺有意思，這篇文章就對視頻做一個歸納總結，程式碼範例都是來自於視頻。

nil是什麼

相信寫過Golang的程式員對下面一段代碼是非常非常熟悉的了：

if err != nil {    // do something....}

當出現不等於nil的時候，說明出現某些錯誤了，需要我們對這個錯誤進行一些處理，而如果等於nil說明運行正常。那什麼是nil呢？查一下詞典可以知道，nil的意思是無，或者是零值。零值，zero value，是不是有點熟悉？在Go語言中，如果你聲明了一個變數但是沒有對它進行賦值操作，那麼這個變數就會有一個類型的預設零值。這是每種類型對應的零值：

bool      -> false                              numbers -> 0                                 string    -> ""      pointers -> nilslices -> nilmaps -> nilchannels -> nilfunctions -> nilinterfaces -> nil

舉個例子，當你定義了一個struct：

type Person struct {  AgeYears int  Name string  Friends []Person}var p Person // Person{0, "", nil}

變數p只聲明但沒有賦值，所以p的所有欄位都有對應的零值。那麼，這個nil到底是什麼呢？Go的文檔中說到，nil是預定義的標識符，代表指標、通道、函數、介面、映射或切片的零值，也就是預定義好的一個變數：

type Type intvar nil Type

是不是有點驚訝？nil並不是Go的關鍵字之一，你甚至可以自己去改變nil的值：

var nil = errors.New("hi")

這樣是完全可以編譯得過的，但是最好不要這樣子去做。

nil有什麼用

在瞭解了什麼是nil之後，再來說說nil有什麼用。

pointers

var p *intp == nil    // true*p          // panic: invalid memory address or nil pointer dereference

指標表示指向記憶體的地址，如果對為nil的指標進行解引用的話就會導致panic。那麼為nil的指標有什麼用呢？先來看一個計算二叉樹和的例子：

type tree struct {  v int  l *tree  r *tree}// first solutionfunc (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 *treesum := 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 *personp.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: Findfunc (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 slicesvar s []slicelen(s)  // 0cap(s)  // 0for range s  // iterates zero timess[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 mapsvar m map[t]ulen(m)  // 0for range m // iterates zero timesv, ok := m[i] // zero(u), falsem[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 channelsvar c chan t<- c      // blocks foreverc <- x    // blocks foreverclose(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還有這麼多用處，真是意外之喜。
油管上面還有很多乾貨滿滿的視頻，可以多學習學習咯。