• 技术文章 >后端开发 >Golang

    go语言nil是什么

    青灯夜游青灯夜游2023-01-11 10:45:27原创72

    nil是Go语言中一个预定义好的标识符,表示空值或零值。在Go语言中,布尔类型的零值(初始值)为 false,数值类型的零值为0,字符串类型的零值为空字符串“''”,而指针、切片、映射、通道、函数和接口的零值则是nil。nil不是关键字或保留字,不同类型nil的指针是一样的,不同类型的nil是不能比较的,相同类型的nil值也可能无法比较。

    本教程操作环境:windows7系统、GO 1.18版本、Dell G3电脑。

    nil是什么

    在Go语言中,布尔类型的零值(初始值)为 false,数值类型的零值为 0,字符串类型的零值为空字符串"",而指针、切片、映射、通道、函数和接口的零值则是 nil。

    nil 是Go语言中一个预定义好的标识符,有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null(NULL),其实这并不是完全正确的,因为Go语言中的 nil 和其他语言中的 null 有很多不同点。

    Go语言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()
    }

    另一个是当tnil的时候会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有三个元素,分别是长度、容量、指向数组的指针:

    1.png

    当有元素的时候:

    2.png

    所以我们并不需要担心slice的大小,使用append的话slice会自动扩容。(视频中说slice自动扩容速度很快,不必担心性能问题,这个值得商榷,在确定slice大小的情况只进行一次内存分配总是好的)

    map

    对于Go来说,map,function,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)
    }

    输出结果是falsedo函数声明了一个*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还有这么多用处,真是意外之喜。
    油管上面还有很多干货满满的视频,可以多学习学习咯。

    【相关推荐:Go视频教程编程教学

    以上就是go语言nil是什么的详细内容,更多请关注php中文网其它相关文章!

    声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn核实处理。
    专题推荐:go语言 Golang
    上一篇:Go语言中什么是包 下一篇:自己动手写 PHP MVC 框架(40节精讲/巨细/新人进阶必看)

    相关文章推荐

    • Go语言变量的生命周期是啥• go语言怎么替换字符串• golang中堆与栈的区别是什么• golang内存泄漏原因有哪些• Go语言类型别名是什么• Go语言怎么导入包
    1/1

    PHP中文网