struct
struct定義結構，結構由字段(field)組成，每個field都有所屬數據類型，在一個struct中，每個字段名都必須唯一。
說白了就是拿來存儲數據的，只不過可自定義化的程度很高，用法很靈活，Go中不少功能依賴於結構，就這樣一個角色。
Go中不支持面向對象，面向對象中描述事物的類的重擔由struct來挑。比如面向對象中的繼承，可以使用組合(composite)來實現：struct中嵌套一個(或多個)類型。面向對象中父類與子類、類與對象的關系是is a的關系，例如Horse is a Animal，Go中的組合則是外部struct與內部struct的關系、struct實例與struct的關系，它們是has a的關系。Go中通過struct的composite，可以"模仿"很多面向對象中的行為，它們很"像"。
定義struct
定義struct的格式如下：
type identifier struct {
field1 type1
field2 type2
…
}
// 或者
type T struct { a, b int }
理論上，每個字段都是有具有唯一性的名字的，但如果確定某個字段不會被使用，可以將其名稱定義為空標識符_來丟棄掉：
type T struct {
_ string
a int
}
每個字段都有類型，可以是任意類型，包括內置簡單數據類型、其它自定義的struct類型、當前struct類型本身、接口、函數、channel等等。
如果某幾個字段類型相同，可以縮寫在同一行：
type mytype struct {
a,b int
c string
}
構造struct實例
定義了struct，就表示定義了一個數據結構，或者說數據類型，也或者說定義了一個類。總而言之，定義了struct，就具備了成員屬性，就可以作為一個抽象的模板，可以根據這個抽象模板生成具體的實例，也就是所謂的"對象"。
例如：
type person struct{
name string
age int
}
// 初始化一個person實例
var p person
這里的p就是一個具體的person實例，它根據抽象的模板person構造而出，具有具體的屬性name和age的值，雖然初始化時它的各個字段都是0值。換句話說，p是一個具體的人。
struct初始化時，會做默認的賦0初始化，會給它的每個字段根據它們的數據類型賦予對應的0值。例如int類型是數值0，string類型是""，引用類型是nil等。
因為p已經是初始化person之后的實例了，它已經具備了實實在在存在的屬性(即字段)，所以可以直接訪問它的各個屬性。這里通過訪問屬性的方式p.FIELD為各個字段進行賦值。
// 為person實例的屬性賦值，定義具體的person
p.name = "longshuai"
p.age = 23
獲取某個屬性的值：
fmt.Println(p.name) // 輸出"longshuai"
也可以直接賦值定義struct的屬性來生成struct的實例，它會根據值推斷出p的類型。
var p = person{name:"longshuai",age:23}
p := person{name:"longshuai",age:23}
// 不給定名稱賦值，必須按字段順序
p := person{"longshuai",23}
p := person{age:23}
p.name = "longshuai"
如果struct的屬性分行賦值，則必須不能省略每個字段后面的逗號","，否則就會報錯。這為未來移除、添加屬性都帶來方便：
p := person{
name:"longshuai",
age:23, // 這個逗號不能省略
}
除此之外，還可以使用new()函數或&TYPE{}的方式來構造struct實例，它會為struct分配內存，為各個字段做好默認的賦0初始化。它們是等價的，都返回數據對象的指針給變量，實際上&TYPE{}的底層會調用new()。
p := new(person)
p := &person{}
// 生成對象后，為屬性賦值
p.name = "longshuai"
p.age = 23
使用&TYPE{}的方式也可以初始化賦值，但new()不行：
p := &person{
name:"longshuai",
age:23,
}
選擇new()還是選擇&TYPE{}的方式構造實例？完全隨意，它們是等價的。但如果想要初始化時就賦值，可以考慮使用&TYPE{}的方式。
struct的值和指針
下面三種方式都可以構造person struct的實例p：
p1 := person{}
p2 := &person{}
p3 := new(person)
但p1和p2、p3是不一樣的，輸出一下就知道了：
package main
import (
"fmt"
)
type person struct {
name string
age int
}
func main() {
p1 := person{}
p2 := &person{}
p3 := new(person)
fmt.Println(p1)
fmt.Println(p2)
fmt.Println(p3)
}
結果：
{ 0}
&{ 0}
&{ 0}
p1、p2、p3都是person struct的實例，但p2和p3是完全等價的，它們都指向實例的指針，指針中保存的是實例的地址，所以指針再指向實例，p1則是直接指向實例。這三個變量與person struct實例的指向關系如下：
變量名 指針 數據對象(實例)
-------------------------------
p1(addr) -------------> { 0}
p2 -----> ptr(addr) --> { 0}
p3 -----> ptr(addr) --> { 0}
所以p1和ptr(addr)保存的都是數據對象的地址，p2和p3則保存ptr(addr)的地址。通常，將指向指針的變量(p1、p2)直接稱為指針，將直接指向數據對象的變量(p1)稱為對象本身，因為指向數據對象的內容就是數據對象的地址，其中ptr(addr)和p1保存的都是實例對象的地址。
但盡管一個是數據對象值，一個是指針，它們都是數據對象的實例。也就是說，p1.name和p2.name都能訪問對應實例的屬性。
那var p4 *person呢，它是什么？該語句表示p4是一個指針，它的指向對象是person類型的，但因為它是一個指針，它將初始化為nil，即表示沒有指向目標。但已經明確表示了，p4所指向的是一個保存數據對象地址的指針。也就是說，目前為止，p4的指向關系如下：
p4 -> ptr(nil)
既然p4是一個指針，那么可以將&person{}或new(person)賦值給p4。
var p4 *person
p4 = &person{
name:"longshuai",
age:23,
}
fmt.Println(p4)
上面的代碼將輸出：
&{longshuai 23}
傳值 or 傳指針
Go函數給參數傳遞值的時候是以復制的方式進行的。
復制傳值時，如果函數的參數是一個struct對象，將直接復制整個數據結構的副本傳遞給函數，這有兩個問題：
- 函數內部無法修改傳遞給函數的原始數據結構，它修改的只是原始數據結構拷貝后的副本
- 如果傳遞的原始數據結構很大，完整地復制出一個副本開銷並不小
所以，如果條件允許，應當給需要struct實例作為參數的函數傳struct的指針。例如：
func add(p *person){...}
既然要傳指針，那struct的指針何來？自然是通過&符號來獲取。分兩種情況，創建成功和尚未創建的實例。
對於已經創建成功的struct實例p，如果這個實例是一個值而非指針(即p->{person_fields})，那么可以&p來獲取這個已存在的實例的指針，然后傳遞給函數，如add(&p)。
對於尚未創建的struct實例，可以使用&person{}或者new(person)的方式直接生成實例的指針p，雖然是指針，但Go能自動解析成實例對象。然后將這個指針p傳遞給函數即可。如：
p1 := new(person)
p2 := &person{}
add(p1)
add(p2)
struct field的tag屬性
在struct中，field除了名稱和數據類型，還可以有一個tag屬性。tag屬性用於"注釋"各個字段，除了reflect包，正常的程序中都無法使用這個tag屬性。
type TagType struct { // tags
field1 bool "An important answer"
field2 string "The name of the thing"
field3 int "How much there are"
}
匿名字段和struct嵌套
struct中的字段可以不用給名稱，這時稱為匿名字段。匿名字段的名稱強制和類型相同。例如：
type animal struct {
name string
age int
}
type Horse struct{
int
animal
sound string
}
上面的Horse中有兩個匿名字段int和animal，它的名稱和類型都是int和animal。等價於：
type Horse struct{
int int
animal animal
sound string
}
顯然，上面Horse中嵌套了其它的struct(如animal)。其中animal稱為內部struct，Horse稱為外部struct。
以下是一個嵌套struct的簡單示例：
package main
import (
"fmt"
)
type inner struct {
in1 int
in2 int
}
type outer struct {
ou1 int
ou2 int
int
inner
}
func main() {
o := new(outer)
o.ou1 = 1
o.ou2 = 2
o.int = 3
o.in1 = 4
o.in2 = 5
fmt.Println(o.ou1) // 1
fmt.Println(o.ou2) // 2
fmt.Println(o.int) // 3
fmt.Println(o.in1) // 4
fmt.Println(o.in2) // 5
}
上面的o是outer struct的實例，但o除了具有自己的顯式字段ou1和ou2，還具備int字段和inner字段，它們都是嵌套字段。一被嵌套，內部struct的屬性也將被外部struct獲取，所以o.int、o.in1、o.in2都屬於o。也就是說，外部struct has a 內部struct，或者稱為struct has a field。
輸出以下外部struct的內容就很清晰了：
fmt.Println(o) // 結果：&{1 2 3 {4 5}}
上面的outer實例，也可以直接賦值構建：
o := outer{1,2,3,inner{4,5}}
在賦值inner中的in1和in2時不能少了inner{}，否則會認為in1、in2是直接屬於outer，而非嵌套屬於outer。
顯然，struct的嵌套類似於面向對象的繼承。只不過繼承的關系模式是"子類 is a 父類"，例如"轎車是一種汽車"，而嵌套struct的關系模式是外部struct has a 內部struct，正如上面示例中outer擁有inner。而且，從上面的示例中可以看出，Go是支持"多重繼承"的。
具名struct嵌套
前面所說的是在struct中以匿名的方式嵌套另一個struct，但也可以將嵌套的struct帶上名稱。
直接帶名稱嵌套struct時，不會再自動深入到嵌套struct中去查找屬性和方法。想要訪問內部struct屬性時，必須帶上該struct的名稱。
例如：
type animal struct {
name string
age int
}
type Horse struct{
a animal
sound string
}
這時候，想要訪問嵌套在Horse中animal的name屬性，則只能通過h.a.name的方式（h為Horse的實例對象），且訪問h.name時將直接報錯，因為在Horse里找不到name屬性。
嵌套struct的名稱沖突問題
假如外部struct中的字段名和內部struct的字段名相同，會如何？
有以下兩個名稱沖突的規則：
- 外部struct覆蓋內部struct的同名字段、同名方法
- 同級別的struct出現同名字段、方法將報錯
第一個規則使得Go struct能夠實現面向對象中的重寫(override)，而且可以重寫字段、重寫方法。
第二個規則使得同名屬性不會出現歧義。例如：
type A struct {
a int
b int
}
type B struct {
b float32
c string
d string
}
type C struct {
A
B
a string
c string
}
var c C
按照規則(1)，直屬於C的a和c會分別覆蓋A.a和B.c。可以直接使用c.a、c.c分別訪問直屬於C中的a、c字段，使用c.d或c.B.d都訪問屬於嵌套的B.d字段。如果想要訪問內部struct中被覆蓋的屬性，可以c.A.a的方式訪問。
按照規則(2)，A和B在C中是同級別的嵌套結構，所以A.b和B.b是沖突的，將會報錯，因為當調用c.b的時候不知道調用的是c.A.b還是c.B.b。
遞歸struct：嵌套自身
如果struct中嵌套的struct類型是自己的指針類型，可以用來生成特殊的數據結構：鏈表或二叉樹(雙端鏈表)。
例如，定義一個單鏈表數據結構，每個Node都指向下一個Node，最后一個Node指向空。
type Node struct {
data string
ri *Node
}
以下是鏈表結構示意圖：
------|---- ------|---- ------|-----
| data | ri | --> | data | ri | --> | data | nil |
------|---- ------|---- ------|-----
如果給嵌套兩個自己的指針，每個結構都有一個左指針和一個右指針，分別指向它的左邊節點和右邊節點，就形成了二叉樹或雙端鏈表數據結構。
二叉樹的左右節點可以留空，可隨時向其中加入某一邊加入新節點(像節點加入到樹中)。添加節點時，節點與節點之間的關系是父子關系。添加完成后，節點與節點之間的關系是父子關系或兄弟關系。
雙端鏈表有所不同，添加新節點時必須讓某節點的左節點和另一個節點的右節點關聯。例如目前已有的鏈表節點A <-> C，現在要將B節點加入到A和C的中間，即A<->B<->C，那么A的右節點必須設置為B，B的左節點必須設置為A，B的右節點必須設置為C，C的左節點必須設置為B。也就是涉及了4次原子性操作，它們要么全設置成功，失敗一個則鏈表被破壞。
例如，定義一個二叉樹：
type Tree struct {
le *Tree
data string
ri *Tree
}
最初生成二叉樹時，root節點沒有任何指向。
// root節點：初始左右兩端為空
root := new(Tree)
root.data = "root node"
隨着節點增加，root節點開始指向其它左節點、右節點，這些節點還可以繼續指向其它節點。向二叉樹中添加節點的時候，只需將新生成的節點賦值給它前一個節點的le或ri字段即可。例如：
// 生成兩個新節點：初始為空
newLeft := new(Tree)
newLeft.data = "left node"
newRight := &Tree{nil, "Right node", nil}
// 添加到樹中
root.le = newLeft
root.ri = newRight
// 再添加一個新節點到newLeft節點的右節點
anotherNode := &Tree{nil, "another Node", nil}
newLeft.ri = anotherNode
簡單輸出這個樹中的節點：
fmt.Println(root)
fmt.Println(newLeft)
fmt.Println(newRight)
輸出結果：
&{0xc042062400 root node 0xc042062420}
&{<nil> left node 0xc042062440}
&{<nil> Right node <nil>}
當然，使用二叉樹的時候，必須為二叉樹結構設置相關的方法，例如添加節點、設置數據、刪除節點等等。
另外需要注意的是，一定不要將某個新節點的左、右同時設置為樹中已存在的節點，因為這樣會讓樹結構封閉起來，這會破壞了二叉樹的結構。