golang：理解 nil 指针和 nil 接口之间的区别

我在思考 nil 在 go 中的不同工作方式，以及有时某些东西可以同时为 nil 和非 nil。

这是一个可以是 nil 指针但不是 nil 接口的小例子。让我们来看看这意味着什么。

接口

首先，go 有一个接口的概念，它与一些面向对象语言中的接口类似，但又不完全相同（根据大多数定义，go 不是 OOP）。在 Go 中，接口是一种类型，它定义了另一个类型必须实现才能满足该接口的函数。这允许我们拥有多种具体类型，可以以不同的方式满足接口。

例如，error 是一个具有单一方法的内置接口。看起来像这样：

type error interface {
    Error() string
}

任何想要用作错误的类型都必须有一个名为 Error 的方法，该方法返回一个字符串。例如，可以使用以下代码：

type ErrorMessage string

func (em ErrorMessage) Error() string {
    return string(em)
}

func DoSomething() error {
    // Try to do something, and it fails.
    if somethingFailed {
        var err ErrorMessage = "This failed"
        return err
    }
    return nil
}

func main() {
    err := DoSomething()
    if err != nil {
        panic(err)
    }
}

请注意，在此示例中，如果出现问题，DoSomething 将返回错误。我们可以使用 ErrorMessage 类型，因为它具有 Error 函数，该函数返回一个字符串，因此实现了错误接口。
如果没有发生错误，我们返回 nil。

指针

在go中，指针指向一个值，但它们也可以指向无值，在这种情况下指针为nil。例如：

var i *int = nil

func main() {
    if i == nil {
        j := 5
        i = &j
    }
    fmt.Println("i is", *i)
}

在这种情况下，i 变量是一个指向 int 的指针。它一开始是一个 nil 指针，直到我们创建一个 int 并将其指向该指针。

指针和接口

由于用户定义的类型可以附加函数（方法），因此我们也可以拥有指向类型的指针的函数。这是Go中很常见的做法。这也意味着指针也可以实现接口。通过这种方式，我们可以得到一个非 nil 接口的值，但仍然是一个 nil 指针。考虑以下代码：

type TruthGetter interface {
    IsTrue() bool
}

func PrintIfTrue(tg TruthGetter) {
    if tg == nil {
        fmt.Println("I can't tell if it's true")
        return
    }
    if tg.IsTrue() {
        fmt.Println("It's true")
    } else {
        fmt.Println("It's not true")
    }
}

任何具有 IsTrue() bool 方法的类型都可以传递给 PrintIfTrue，但 nil 也可以。所以，我们可以执行 PrintIfTrue(nil) ，它会打印“我无法判断它是否为真”。

我们也可以做一些简单的事情，比如这样：

type Truthy bool

func (ty Truthy) IsTrue() bool {
    return bool(ty)
}

func main() {
    var ty Truthy = true
    PrintIfTrue(ty)
}

这将打印“It's true”。

或者，我们可以做一些更复杂的事情，例如：

type TruthyNumber int

func (tn TruthyNumber) IsTrue() bool {
    return tn > 0
}

func main() {
    var tn TruthyNumber = -4
    PrintIfTrue(tn)
}

这将打印“这不是真的”。这些示例都不是指针，因此这些类型都不可能出现 nil，但请考虑这一点：

type TruthyPerson struct {
    FirstName string
    LastName string
}

func (tp *TruthyPerson) IsTrue() bool {
    return tp.FirstName != "" && tp.LastName != ""
}

在这种情况下，TruthyPerson 不会实现 TruthGetter，但 *TruthyPerson 会实现。所以，这应该有效：

func main() {
    tp := &TruthyPerson{"Jon", "Grady"}
    PrintIfTrue(tp)
}

这是有效的，因为 tp 是一个指向 TruthyPerson 的指针。然而，如果指针为零，我们就会感到恐慌。

func main() {
    var tp *TruthyPerson
    PrintIfTrue(tp)
}

这会引起恐慌。但是，PrintIfTrue 中不会发生恐慌。您可能会认为这很好，因为 PrintIfTrue 检查是否为 nil。但是，问题就在这里。它正在针对 TruthGetter 检查 nil。换句话说，它检查的是 nil 接口，而不是 nil 指针。在 func (tp *TruthyPerson) IsTrue() bool 中，我们不检查 nil。在 go 中，我们仍然可以在 nil 指针上调用方法，因此恐慌发生在那里。修复实际上非常简单。

func (tp *TruthyPerson) IsTrue() bool {
    if tp == nil {
        return false
    }
    return tp.FirstName != "" && tp.LastName != ""
}

现在，我们检查 PrintIfTrue 中是否有 nil 接口以及 func (tp *TruthyPerson) IsTrue() bool 中是否有 nil 指针。现在它会打印“这不是真的”。我们可以看到所有这些代码都在这里工作。

奖励：通过反射立即检查两个 nil

通过反射，我们可以对 PrintIfTrue 进行一些小更改，以便它可以检查 nil 接口和 nil 指针。代码如下：

func PrintIfTrue(tg TruthGetter) {
    if tg == nil {
        fmt.Println("I can't tell if it's true")
        return
    }

    val := reflect.ValueOf(tg)
    k := val.Kind()
    if (k == reflect.Pointer || k == reflect.Chan || k == reflect.Func || k == reflect.Map || k == reflect.Slice) && val.IsNil() {
        fmt.Println("I can't tell if it's true")
        return
    }

    if tg.IsTrue() {
        fmt.Println("It's true")
    } else {
        fmt.Println("It's not true")
    }
}

在这里，我们像以前一样首先检查 nil 接口。接下来，我们使用反射来获取类型。除了指针之外，chan、func、map 和 slice 也可以为 nil，因此我们检查该值是否是这些类型之一，如果是，则检查它是否为 nil。如果是，我们也会返回“我无法判断这是否是真的”消息。这可能是也可能不是您想要的，但它是一个选择。通过此更改，我们可以执行以下操作：

func main() {
    var tp *TruthyPerson
    PrintIfTrue(tp)
}

您有时可能会看到一些更简单的建议，例如：

// Don't do this
if tg == nil && reflect.ValueOf(tg).IsNil() {
    fmt.Println("I can't tell if it's true")
    return
}

这效果不好有两个原因。首先，使用反射时会产生性能开销。如果您可以避免使用反射，那么您可能应该这样做。如果我们首先检查 nil 接口，那么如果它是 nil 接口，我们就不必使用反射。

第二个原因是，如果值的类型不是可以为 nil 的类型，reflect.Value.IsNil() 将会发生恐慌。这就是我们添加此类检查的原因。如果我们没有检查 Kind，那么我们会对 Truthy 和 TruthyNumber 类型感到恐慌。

因此，只要我们确保首先检查类型，现在就会打印“我无法判断它是否为真”，而不是“这不是真的”。根据您的观点，这可能是一种改进。这是进行此更改的完整代码。

本文最初发表于 Dan's Musings

以上是golang：理解 nil 指针和 nil 接口之间的区别的详细内容。更多信息请关注PHP中文网其他相关文章！