Go?语言选择器实例教程

 更新时间:2022年07月14日 11:34:34   作者:cureking  
这篇文章主要为大家介绍了Go?语言选择器实例教程,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
(福利推荐:【腾讯云】服务器最新限时优惠活动,云服务器1核2G仅99元/年、2核4G仅768元/3年,立即抢购>>>:9i0i.cn/qcloud

(福利推荐:你还在原价购买阿里云服务器?现在阿里云0.8折限时抢购活动来啦!4核8G企业云服务器仅2998元/3年,立即抢购>>>:9i0i.cn/aliyun

引言

在 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 <= 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

在 hood 下

如果你对选择器朝朝和验证的实际实现感兴趣的话,请查看 selector 和 LookupFieldOrMethod 函数。

以上就是Go 语言选择器实例教程的详细内容,更多关于Go 选择器教程的资料请关注程序员之家其它相关文章!

相关文章

  • Golang学习笔记之延迟函数(defer)的使用小结

    Golang学习笔记之延迟函数(defer)的使用小结

    这篇文章主要介绍了Golang学习笔记之延迟函数(defer),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-12-12
  • Go位集合相关操作bitset库安装使用

    Go位集合相关操作bitset库安装使用

    这篇文章主要为大家介绍了Go位集合相关操作bitset库安装使用,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-07-07
  • go实现base64编码的四种方式

    go实现base64编码的四种方式

    本文主要介绍了go实现base64编码的四种方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-03-03
  • Golang因Channel未关闭导致内存泄漏的解决方案详解

    Golang因Channel未关闭导致内存泄漏的解决方案详解

    这篇文章主要为大家详细介绍了当Golang因Channel未关闭导致内存泄漏时盖如何解决,文中的示例代码讲解详细,感兴趣的小伙伴可以了解一下
    2023-07-07
  • 深入探讨Go语言中的map是否是并发安全以及解决方法

    深入探讨Go语言中的map是否是并发安全以及解决方法

    这篇文章主要来和大家探讨?Go?语言中的?map?是否是并发安全的,并提供三种方案来解决并发问题,文中的示例代码讲解详细,需要的可以参考一下
    2023-05-05
  • Go Web下gin框架的模板渲染的实现

    Go Web下gin框架的模板渲染的实现

    Gin框架是目前非常流行的Go语言Web框架之一,作为一个轻量级的框架,Gin提供了丰富的功能和灵活的架构,本文就来介绍下Go Web下gin框架的模板渲染的实现,感兴趣的可以了解一下
    2023-10-10
  • Golang开发之接口的具体使用详解

    Golang开发之接口的具体使用详解

    在 Golang 中,接口是一种类型,它是由一组方法签名组成的抽象集合。这篇文章主要为大家介绍了Golang接口的具体使用,希望对大家有所帮助
    2023-04-04
  • go单体日志采集zincsearch方案实现

    go单体日志采集zincsearch方案实现

    这篇文章主要为大家介绍了go单体日志采集zincsearch方案实现示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-07-07
  • Go语言每天必学之switch语句

    Go语言每天必学之switch语句

    这篇文章主要为大家详细介绍了Go语言每天必学之switch语句的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-12-12
  • Golang中的archive/zip包的常用函数详解

    Golang中的archive/zip包的常用函数详解

    Golang 中的 archive/zip 包用于处理 ZIP 格式的压缩文件,提供了一系列用于创建、读取和解压缩 ZIP 格式文件的函数和类型,下面小编就来和大家讲解下常用函数吧
    2023-08-08

最新评论

?


http://www.vxiaotou.com