Go 语言选择器实例教程

旺仔小馒头

引言

在 Go 语言中，表达式

1. foo.bar

复制代码

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

1. package foo
   
2. import "fmt"
   
3. func Foo() {
   
4.     fmt.Println("foo")
   
5. }
   
6. func bar() {
   
7.     fmt.Println("bar")
   
8. }
   
9. package main
   
10. import "github.com/mlowicki/foo"
    
11. func main() {
    
12.     foo.Foo()
    
13. }

复制代码

这样的程序会工作正常。但是（主函数）调用

1. foo.bar()

复制代码

会在编译时报错 —— cannot refer to unexported name foo.bar(无法引用未导出的名称 foo.bar)。
如果 foo 不是 一个包名，那么

1. foo.bar

复制代码

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

1. package main
   
2. import "fmt"
   
3. type T struct {
   
4.     age byte
   
5. }
   
6. func main() {
   
7.     fmt.Println(T{age: 30}.age)
   
8. }

复制代码

该程序打印：

1. 30

复制代码

选择器的深度

语言规范定义了选择器的 depth（深度）。让我们来看看它是如何工作的吧。选择器表达式

1. foo.bar

复制代码

可以表示定义在 foo 类型的字段或方法或者定义在 foo 类型中的匿名字段：

1. type E struct {
   
2.     name string
   
3. }
   
4. func (e E) SayHi() {
   
5.     fmt.Printf("Hi %s!\n", e.name)
   
6. }
   
7. type T struct {
   
8.     age byte
   
9.     E
   
10. }
    
11. func (t T) IsStillYoung() bool {
    
12.     return t.age <= 18
    
13. }
    
14. func main() {
    
15.     t := T{30, E{"Michał"}}
    
16.     fmt.Println(t.IsStillYoung()) // false
    
17.     fmt.Println(t.age) // 30
    
18.     t.SayHi() // Hi Michał!
    
19.     fmt.Println(t.name) // Michał
    
20. }

复制代码

在上面的代码中，我们可以看到可以调用方法或者访问定义在嵌入字段中字段。字段

1. t.name

复制代码

和方法

1. t.SayHi

复制代码

都被提升了，这是因为类型 E 嵌套在 T 的定义中：

1. type T struct {
   
2.     age byte
   
3.     E
   
4. }

复制代码

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

1. package main
   
2. import "fmt"
   
3. type A struct {
   
4.     a string
   
5. }
   
6. type B struct {
   
7.     b string
   
8.     A
   
9. }
   
10. type C struct {
    
11.     c string
    
12.     B
    
13. }
    
14. func main() {
    
15.     v := C{"c", B{"b", A{"a"}}}
    
16.     fmt.Println(v.c) // c
    
17.     fmt.Println(v.b) // b
    
18.     fmt.Println(v.a) // a
    
19. }

复制代码

• c 的深度是
  1. v.c

  复制代码
  ，其值为 0。这是因为字段是在 C 中声明的
  
• 1. v.b

  复制代码
  中 b 的深度是 1。这是因为它的字段定义在类型 B 中，其（类型B）又嵌入在 C 中
  
• 1. v.a

  复制代码
  中 a 的深度是 2。这是因为需要遍历两个匿名字段（B 和 A）才能访问它
  

有效选择器

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

唯一性+最浅深度

当 T 不是指针或者接口类型，第一条规则适用于类型

1. T

复制代码

与

1. *T

复制代码

。选择器 foo.bar 表示字段和方法在定义了 bar 的类型 T 中的最浅深度。在这样的深度，恰好可以定义一个（唯一的）这样的字段或者方法源代码：

1. type A struct {
   
2.     B
   
3.     C
   
4. }
   
5. type B struct {
   
6.     age byte
   
7.     name string
   
8. }
   
9. type C struct {
   
10.     age byte
    
11.     D
    
12. }
    
13. type D struct {
    
14.     name string
    
15. }
    
16. func main() {
    
17.     a := A{B{1, "b"}, C{2, D{"d"}}}
    
18.     fmt.Println(a) // {{1 b} {2 {d}}}
    
19.     // fmt.Println(a.age) ambiguous selector a.age
    
20.     fmt.Println(a.name) // b
    
21. }

复制代码

类型嵌入的结构如下：

1. A
   
2. / \
   
3. B   C
   
4.      \
   
5.       D

复制代码

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

1. ambiguous selector a.age

复制代码

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

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

复制代码

值得重申的是，该规则也适用于

1. *T

复制代码

—— 例子。

空指针

1. package main
   
2. import "fmt"
   
3. type T struct {
   
4.     num int
   
5. }
   
6. func (t T) m() {}
   
7. func main() {
   
8.     var p *T
   
9.     fmt.Println(p.num)
   
10.     p.m()
    
11. }

复制代码

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

1. runtime panic：panic invalid memory address or nil pointer dereference

复制代码

接口

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

1. type I interface {
   
2.     m()
   
3. }
   
4. type T struct{}
   
5. func (T) m() {
   
6.     fmt.Println("I'm alive!")
   
7. }
   
8. func main() {
   
9.     var i I
   
10.     i = T{}
    
11.     i.m()
    
12. }

复制代码

上面的片段输出

1. I'm alive!

复制代码

。当然，调用不在接口的方法集合中的方法时，会产生编译时错误，如

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

复制代码

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

1. type I interface {
   
2.     f()
   
3. }
   
4. func main() {
   
5.     var i I
   
6.     i.f()
   
7. }

复制代码

这样的程序将会因为错误

1. panic: runtime error: invalid memory address or nil pointer dereference

复制代码

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

一个特殊情况

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

1. type P *T

复制代码

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

1. type T struct {
   
2.     num int
   
3. }
   
4. func (t T) m() {}
   
5. type P *T
   
6. func main() {
   
7.     var p P = &T{num: 10}
   
8.     fmt.Println(p.num)
   
9.     // p.m() // compile-time error: p.m undefined (type P has no field or method m)
   
10.     (*p).m()
    
11. }

复制代码

1. p.num

复制代码

在 hood 下被转化为

1. (*p).num

复制代码

。

在 hood 下

如果你对选择器朝朝和验证的实际实现感兴趣的话，请查看 selector 和 LookupFieldOrMethod 函数。
以上就是Go 语言选择器实例教程的详细内容，更多关于Go 选择器教程的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

夏洛灵

看看，学习学习～～～～

童竹月

感谢楼主分享～～～～～

拿渡朱德栗

感谢楼主分享。

师秀逸

感谢楼主，顶。

廊桥遗梦504

顶顶更健康！！！