关于go:golang中的nil接收器

索引：https://waterflow.link/articles/1666534616841

咱们先看一个简略的例子，咱们自定义一个谬误，用来把多个谬误放在一起输入：

type CustomError struct {errors []string
}

func (c *CustomError) Add(err string) {c.errors = append(c.errors, err)
}

func (c *CustomError) Error() string {return strings.Join(c.errors, ";")
}

因为实现了 Error() string 办法，所以它实现了 error 接口。

当初咱们要实现一个增加课件的性能，然而增加之前须要验证参数的合法性，所以咱们创立了一个 Validate 办法，咱们可能会这么写：

package main

import (
    "errors"
    "fmt"
    "strings"
)

type CustomError struct {errors []string
}

func (c *CustomError) Add(err error) {c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {return strings.Join(c.errors, ";")
}

type Courseware struct {
    Name string
    Code string
}

func (c *Courseware) Validate() error {
    var m *CustomError // 1
    if c.Name == "" { // 2
        m = &CustomError{}
        m.Add(errors.New("课件名不能为空"))
    }
    if c.Code == "" { // 3
        if m == nil {m = &CustomError{}
        }
        m.Add(errors.New("课件编号不能为空"))
    }

    return m // 4
}

func main() {
    m := Courseware{
        Name: "多媒体课件",
        Code: "CW330",
    }
    if err := m.Validate(); err != nil {fmt.Println("valid err:", err)
    }
}

看上去如同一点问题都没有：

1. 定义一个 CustomError 类型的指针
2. 如果 Name 为空，初始化 m，调用 Add 办法把谬误增加到 CustomError.errors
3. 如果 Code 为空，如果 m 还没有初始化，先初始化，调用 Add 办法把谬误增加到 CustomError.errors
4. 最初返回自定义谬误

然而当咱们执行下面的代码时，会发现后果并不是咱们想要的：

go run 8.go
valid err:  <nil>

咱们发现竟然走到了打印谬误的判断里，然而打印进去的谬误竟然是一个nil。

在 Go 中，咱们必须晓得指针接收器能够为 nil。咱们看一个简略的例子：

package main

import ("fmt")

type Demo struct {
}

func (d *Demo) Print() string {return "demo"}

func main() {
    var d *Demo
    fmt.Println(d)
    fmt.Println(d.Print())
}

go run 8.go
<nil>
demo

Demo 被初始化为 nil，然而这段代码能够失常运行。阐明 nil 指针也能够作为接收器。

其实下面的 Print 办法等价于：

func Print(d *Demo) string {return "demo"}

因为将 nil 指针传递给函数是无效的。所以应用 nil 指针作为接收器也是无效的。

咱们持续回到下面的自定义谬误。

m 被初始化为指针的零值：nil。如果所有验证都通过，return 语句返回的后果不是 nil，而是一个 nil 指针。因为 nil 指针是一个无效的接收器，所以将后果转换为 error 接口不会产生 nil 值。

所以咱们尽管返回了一个 nil 指针，然而转换为 error 接口时并不是一个 nil 的接口（尽管是 nil 指针，然而是 *CustomError 类型，并实现了 error）。

要解决这个问题，咱们只有间接返回 nil 值，不返回 nil 的指针：

package main

import (
    "errors"
    "fmt"
    "strings"
)

type CustomError struct {errors []string
}

func (c *CustomError) Add(err error) {c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {return strings.Join(c.errors, ";")
}

type Courseware struct {
    Name string
    Code string
}

func (c *Courseware) Validate() error {
    var m *CustomError
    if c.Name == "" {m = &CustomError{}
        m.Add(errors.New("课件名不能为空"))
    }
    if c.Code == "" {
        if m == nil {m = &CustomError{}
        }
        m.Add(errors.New("课件编号不能为空"))
    }

  // 这里如果 m 指针为 nil，间接返回 nil
    if m == nil {return nil}

    return m
}

func main() {
    m := Courseware{
        Name: "多媒体课件",
        Code: "CW330",
    }

    if err := m.Validate(); err != nil {fmt.Println("valid err:", err)
    }
}

或者咱们间接返回 *CustomError 类型的谬误：

package main

import (
    "errors"
    "fmt"
    "strings"
)

type CustomError struct {errors []string
}

func (c *CustomError) Add(err error) {c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {return strings.Join(c.errors, ";")
}

type Courseware struct {
    Name string
    Code string
}

// 返回 *CustomError
func (c *Courseware) Validate() *CustomError {
    var m *CustomError
    if c.Name == "" {m = &CustomError{}
        m.Add(errors.New("课件名不能为空"))
    }
    if c.Code == "" {
        if m == nil {m = &CustomError{}
        }
        m.Add(errors.New("课件编号不能为空"))
    }

    return m
}

func main() {
    m := Courseware{
        Name: "多媒体课件",
        Code: "CW330",
    }

    if err := m.Validate(); err != nil {fmt.Println("valid err:", err)
    }
}

但这并不是可取的，为了扩大咱们实现了 error 接口，也须要返回 error 类型的谬误。