Go基礎系列：struct的導出和暴露問題

struct的導出和暴露問題

關於struct的導出

struct的屬性是否被導出，也遵循大小寫的原則：首字母大寫的被導出，首字母小寫的不被導出。

因此：

1. 若是struct名稱首字母是小寫的，這個struct不會被導出。連同它裏面的字段也不會導出，即便有首字母大寫的字段名。
   
2. 若是struct名稱首字母大寫，則struct會被導出，但只會導出它內部首字母大寫的字段，那些小寫首字母的字段不會被導出。

也就是說，struct的導出狀況是混合的。

但並不是絕對如此，若是struct嵌套了，那麼即便被嵌套在內部的struct名稱首字母小寫，也能訪問到它裏面首字母大寫的字段。

例如：

type animal struct{
    name string
    Speak string
}
type Horse struct {
    animal
    sound string
}

Horse中嵌套的animal是小寫字母開頭的，但Horse是能被導出的，因此能在其它包中使用Horse struct，其餘包也能訪問到animal中的Speak屬性。

不少時候，Horse這個名字是不安全的，由於這表示導出Horse這個struct給其餘包，也就是將Horse給暴露出去了，外界能夠直接打開Horse這個"黑匣子"。

但若是不將Horse導出，如何能在其它包構建出Horse實例？見下文。

不要暴露struct

不少時候，不該該將某包(如包abc)中的struct(如animal)直接暴露給其它包，暴露意味着打開了那個"黑匣子"，因此struct會以小寫字母開頭，不將其導出。

這時在外界其它包中構建包abc的animal，就無法直接經過如下幾種方式實現：

• var xxx abc.animal
• new(abc.animal)
  
• &abc.animal{...}
  
• abc.animal{...}

例如，下面的是錯誤的：

// abc/abc.go文件內容：
package abc

type animal struct{
    name string
    Speak string
}

// test.go內容：
package main

import "./abc"

func main() {
    // 全都錯誤
    var t1 abc.animal
    t2 := new(abc.animal)
    t3 := &abc.animal{}
    t4 := abc.animal{}
}

那麼如何在外界構建隱藏起來的struct實例？這時能夠在abc包中寫一個可導出的函數，經過這個函數來構建struct實例。例如：

// abc/abc.go文件內容：
package abc

type animal struct{
    name string
    Speak string
}

func NewAnimal() *animal{
    a := new(animal)
    return a
}


// test.go內容：
package main

import (
    "fmt"
    "./abc"
)

func main() {
    t1 := abc.NewAnimal()
//  t1.name = "haha"    // 沒法訪問name屬性
    t1.Speak = "hhhh"
    fmt.Println(t1.Speak)
}

上面的代碼一切正常，在main包中能夠經過NewAnimal()構建出abc包中未導出的animal struct。注意，上面NewAnimal()中是使用new()函數構造實例的，它返回的是實例的指針，至於如何構造實例，徹底能夠根據本身的需求，但對於struct類型來講，通常都是使用指針的，也就是徹底能夠將new()通用化。

因爲animal中的name字段是不導出的字段，因此在外界即使是經過NewAnimal()構建出了animal實例，也沒法訪問該實例的name屬性，因此無法爲name字段賦值。換句話說，name屬性永遠是初始化的0值。

所以，爲了讓構建實例時自定義name屬性，須要在構造方法NewAnimal()上指定設置給name屬性的參數。修改NewAnimal()函數：

func NewAnimal(name string) *animal{
    a := new(animal)
    a.name = name
    return a
}

而後在其它包中構建animal實例：

t1 := abc.NewAnimal("longshuai")

雖然其它包中構建的animal實例已經具有了name屬性，但仍是沒法訪問該實例的name屬性。因此，在abc包中繼續寫一個可導出的方法，該方法用於獲取實例的name屬性：

// abc/abc.go中添加：
func (a *animal) GetName() string {
    return a.name
}

因而外界包中能夠經過這個導出的方法獲取實例的name屬性：

t1 := abc.NewAnimal("longshuai")
fmt.Println(t1.GetName())

實際上，上面NewAnimal()構造對象時，能夠不用傳遞name參數，而是像GetName()同樣，寫一個專門的可導出方法來設置實例的name屬性。改寫abc/abc.go中的代碼：

func NewAnimal() *animal{
    a := new(animal)
    return a
}
func (a *animal) SetName(name string){
    a.name = name
}

如今，abc/abc.go中的animal struct就徹底對外隱藏了。

但須要注意的是，上面的setter類方法SetName()不能同時被2個或多個線程修改，不然值被覆蓋，出現線程安全問題，可使用sync包或者goroutine和channel來解決這個問題。

嵌套struct中的方法導出問題

當內部struct嵌套進外部struct時，內部struct的方法也會被嵌套，也就是說外部struct擁有了內部struct的方法。

可是須要注意方法的首字母大小寫問題。因爲內、外struct在同一包內，因此直接在該包內構建外部struct實例，外部struct實例是能夠直接訪問內部struct的全部方法的。但若是在其它包內構建外部struct實例，該實例將沒法訪問內部struct中首字母小寫的方法。

如下是在同一個包內測試，外部實例能夠直接調用內部struct的方法：

package main

import (
    "fmt"
)

type person struct {
    name string
    age  int
}

// 未導出方法
func (p *person) speak() {
    fmt.Println("speak in person")
}

// 導出的方法
func (p *person) Sing() {
    fmt.Println("Sing in person")
}

// Admin exported
type Admin struct {
    person
    salary int
}

func main() {
    a := new(Admin)
    a.speak()  // 正常輸出
    a.Sing()   // 正常輸出
}

執行結果時a.speak()和a.Sing()都正常輸出。

如下是不一樣包內測試，struct定義在abc/abc.go文件中，main在test.go中，它們的目錄結構以下：

$ tree .
.
├── abc
│   └── abc.go
├── test.go

abc/abc.go的內容爲：

package abc

import "fmt"

// 未導出的person
type person struct {
    name string
    age  int
}

// 未導出的方法
func (p *person) speak() {
    fmt.Println("speak in person")
}

// 導出的方法
func (p *person) Sing() {
    fmt.Println("Sing in person")
}

// Admin exported
type Admin struct {
    person
    salary int
}

test.go的內容爲：

package main

import "./abc"

func main() {
    a := new(abc.Admin)

    // 下面報錯
//  a.speak()

    // 下面正常
    a.Sing()
}

執行結果是，a.speak()報錯，但a.Sing()正常。