Go语言选择器实例分析

今天小编给大家分享一下Go语言选择器实例分析的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。引言在Go

今天小编给大家分享一下Go语言选择器实例分析的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。

    引言

    在 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语言选择器实例分析”这篇文章的所有内容,感谢各位的阅读!相信大家阅读完这篇文章都有很大的收获,小编每天都会为大家更新不同的知识,如果还想学习更多的知识,请关注恰卡网行业资讯频道。

    本站部分文章来自网络或用户投稿,如无特殊说明或标注,均为本站原创发布。涉及资源下载的,本站旨在共享仅供大家学习与参考,如您想商用请获取官网版权,如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。
    开发者

    Python中闭包与lambda的作用域怎么写

    2022-8-3 21:06:14

    开发者

    in_array的第3个参数实例分析

    2022-8-3 21:06:17

    搜索