Go 語言選擇器範例教學

2022-07-14 14:01:15

引言

在 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.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。