为什么golang nil指针取消引用发生在子方法中

Question

我有这个代码

package main

import "fmt"

type Foo struct {
    Bar string
}

func (f *Foo) level4() {
    fmt.Printf("Bar = %s\n", f.Bar)
}

func (f *Foo) level3() {
    f.level4() // panics here, 2 levels down
}

func (f *Foo) level2() {
    f.level3()
}

func (f *Foo) level1() {
    f.level2()
}

type FooWrapper struct {
    foo *Foo
}

func main() {
    w := FooWrapper{}
    w.foo.level1() // expected it to panic here, since foo is nil
}

正如预期的那样，运行它会给出

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x47f454]

但是，我预计 nil 指针取消引用会发生在 w.foo.level1()，因为 foo 是 nil。相反，它会调用级别 1、2 和 3 并在那里发生恐慌。为什么会这样？

playground link

Answer 1

为什么会这样？

因为 w.foo.level1() 是有效语句，同样 f.level2()、f.level3()、f.level4() 也是有效语句。

试试这个

func (f *Foo) level1() {
    println("Hello Go")
    f.level2()
}

它将打印 Hello Go 并调用 f.level2() 并查看最后调用级别 4

func (f *Foo) level4() {
    println("Hello Go 4")
    fmt.Printf("Bar = %s\n", f.Bar) 
}

它将打印Hello Go 4，但在下一行显示跟踪时会出现恐慌，或者您可以说出错误的来源

Answer 2

任何指针类型的默认值为nil。

当您使用构建对象时

w := FooWrapper{}

foo 的值将被分配默认的nil。

要解决问题，您应该传递一个 foo 的值。

w := FooWrapper{foo: &Foo{Bar: "bar"}}

为了防止这个问题，我通常会做一些构造函数。

func NewFooWrapper() *FooWrapper {
   return &FooWrapper{foo: &Foo{Bar: "bar"}}
}

w := NewFooWrapper()

或者如果foo 的值不能被硬编码。

func NewFooWrapper(foo *Foo) *FooWrapper {
   return &FooWrapper{foo: foo}
}

w := NewFooWrapper(&Foo{Bar: "bar"})

从编码的角度来看，这使得它更加明确，可以防止在其他代码位置出现这些错误。

Answer 3

您没有正确初始化 main 函数中的 FooWrapper。您的 foo 类型为 *Foo 的字段在 w 变量类型为 FooWrapper 内是 nil，因为您尚未为其分配值，并且指针类型变量的默认值为 Go 中的 nil

简单正确的初始化如下

    w := FooWrapper{
        foo: &Foo{
            Bar: "bar",
        },
    }

在playground运行

输出：

Bar = bar

恐慌没有出现在level1()、level2()、level3() 中的原因是它们没有在这些函数中使用任何Foo 的字段。而且在level4() 中发生恐慌不是因为函数调用，而是因为它在打印中使用了f.Bar。

在围棋中，

如果接口本身的具体值是 nil，则该方法将使用 nil 接收器调用。

你可以在https://go.dev/tour/methods/12找到一个简单的例子

您还可以在 Calls 下的 Go 规范文档中找到很好的解释

如果 x 的（类型）的方法集包含 m 并且参数列表可以分配给 m 的参数列表，则方法调用 x.m() 是有效的。如果 x 是可寻址的且 &x 的方法集包含 m，则 x.m() 是 (&x).m() 的简写