引言

在 Go 语言中，表达式foo.bar可能表示两件事。如果foo是一个包名，那么表达式就是一个所谓的限定标识符，用来引用包foo中的导出的标识符。由于它只用来处理导出的标识符，bar必须以大写字母开头(译注：如果首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用）：

package foo
import "fmt"
func Foo() {

    fmt.Println("foo")
}

func bar() {

    fmt.Println("bar")
}

package main
import "github.com/mlowicki/foo"
func main() {

    foo.Foo()
}

这样的程序会工作正常。但是（主函数）调用foo.bar()会在编译时报错 ——cannot refer to unexported name foo.bar(无法引用未导出的名称 foo.bar)。

如果foo不是 一个包名，那么foo.bar就是一个选择器表达式。它访问foo表达式的字段或方法。点之后的标识符被称为selector（选择器）。关于首字母大写的规则并不适用于这里。它允许从定义了foo类型的包中选择未导出的字段或方法：

package main
import "fmt"
type T struct {

    age byte
}

func main() {

    fmt.Println(T{
age: 30}
.age)
}

该程序打印：

30

选择器的深度

语言规范定义了选择器的depth（深度）。让我们来看看它是如何工作的吧。选择器表达式foo.bar可以表示定义在foo类型的字段或方法或者定义在foo类型中的匿名字段：

type E struct {

    name string
}

func (e E) SayHi() {

    fmt.Printf("Hi %s!\n", e.name)
}

type T struct {

    age byte
    E
}

func (t T) IsStillYoung() bool {
    
    return t.age &
    lt;
= 18
}

func main() {

    t := T{
30, E{
"Michał"}
}

    fmt.Println(t.IsStillYoung()) // false
    fmt.Println(t.age) // 30
    t.SayHi() // Hi Michał!
    fmt.Println(t.name) // Michał
}

在上面的代码中，我们可以看到可以调用方法或者访问定义在嵌入字段中字段。字段t.name和方法t.SayHi都被提升了，这是因为类型E嵌套在T的定义中：

type T struct {

    age byte
    E
}

定义在类型T中表示字段或类型的选择器深度为 0（译注：表示在类型 T 中定义的字段或方法的选择器的深度为 0）。如果字段或方法定义在嵌入（也就是 匿名）字段，那么深度等于匿名字段遍历这样字段或方法的数量。在上一个片段中，age字段深度是 0，因为它在T中声明，但是因为E是放在T中，name或者SayHi的深度是 1。让我们来看看更复杂的例子：

package main
import "fmt"
type A struct {

    a string
}

type B struct {

    b string
    A
}

type C struct {

    c string
    B
}

func main() {

    v := C{
"c", B{
"b", A{
"a"}
}
}

    fmt.Println(v.c) // c
    fmt.Println(v.b) // b
    fmt.Println(v.a) // a
}

• c的深度是v.c，其值为 0。这是因为字段是在C中声明的
• v.b中b的深度是 1。这是因为它的字段定义在类型B中，其（类型B）又嵌入在C中
• v.a中a的深度是 2。这是因为需要遍历两个匿名字段（B和A）才能访问它

有效选择器

go 语言中有关哪些选择器有效，哪些无效有着明确规则。让我们来深入了解他们。

唯一性+最浅深度

当T不是指针或者接口类型，第一条规则适用于类型T与*T。选择器foo.bar表示字段和方法在定义了bar的类型T中的最浅深度。在这样的深度，恰好可以定义一个（唯一的）这样的字段或者方法源代码：

type A struct {

    B
    C
}

type B struct {

    age byte
    name string
}

type C struct {

    age byte
    D
}

type D struct {

    name string
}

func main() {

    a := A{
B{
1, "b"}
, C{
2, D{
"d"}
}
}

    fmt.Println(a) // {
{
1 b}
 {
2 {
d}
}
}

    // fmt.Println(a.age) ambiguous selector a.age
    fmt.Println(a.name) // b
}

类型嵌入的结构如下：

 A
 / \
B   C
     \
      D

选择器a.name是有效的，并且表示字段name（B类型内）的深度为 1。C类型中的字段name是 “shadowed(浅的）”。有关age字段则是不同的。在深度 1 处有这样两个字段（在B和C类型中），所以编译器会抛出ambiguous selector a.age错误。

当被提升的字段或方法有歧义时，Gopher 仍然可以使用完整的选择器。

fmt.Println(a.B.name)   // b
fmt.Println(a.C.D.name) // d
fmt.Println(a.C.name)   // d

值得重申的是，该规则也适用于*T——例子。

空指针

package main
import "fmt"
type T struct {

    num int
}

func (t T) m() {
}

func main() {

    var p *T
    fmt.Println(p.num)
    p.m()
}

如果选择器是有效的，但foo是一个空指针，那么评估foo.bar造成

runtime panic：panic invalid memory address or nil pointer dereference

接口

如果foo是一个接口类型值，那么foo.bar实际上是foo的动态值的一个方法：

type I interface {

    m()
}

type T struct{
}

func (T) m() {

    fmt.Println("I'm alive!")
}

func main() {

    var i I
    i = T{
}

    i.m()
}

上面的片段输出I'm alive!。当然，调用不在接口的方法集合中的方法时，会产生编译时错误，如

i.f undefined (type I has no field or method f)

如果foo为nil，那么它将会导致一个运行时错误：

type I interface {

    f()
}

func main() {

    var i I
    i.f()
}

这样的程序将会因为错误panic: runtime error: invalid memory address or nil pointer dereference而崩溃。

这和空指针情况类似，而且由于诸如没有值赋值和接口零值为nil而发生错误。

一个特殊情况

除了到现在为止关于有效选择器的描述外，这还有一个场景：假设这里有一个命名指针类型：

type P *T

类型P的方法集不包含类型T的任何方法。如果有类型P的变量，则无法调用任何T的方法。但是，规范允许选择类型T的字段（非方法）源代码：

type T struct {

    num int
}

func (t T) m() {
}

type P *T
func main() {
    
    var p P = &
T{
num: 10}

    fmt.Println(p.num)
    // p.m() // compile-time error: p.m undefined (type P has no field or method m)
    (*p).m()
}
    

p.num在 hood 下被转化为(*p).num。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！