Go 結構體與初始化

Go 經過類型別名（alias types）和結構體的形式支持用戶自定義類型。
結構體是複合類型，當須要定義類型，它由一系列屬性組成，每一個屬性都有本身的類型和值的時候，就應該使用結構體，它把數據彙集在一塊兒。

結構體也是值類型，所以能夠經過 new 函數來建立

組成結構體類型的那些數據成爲字段（fields）。每一個字段都有一個類型和一個名字；在一個結構體中，字段名字必須是惟一的。

一，結構體定義

結構體定義的通常方式以下：

type identifier struct {
    field type1
    field type2
}

type T struct {a, b int} 也是合法的語法，它更適用於簡單的結構體
結構體裏的字段都有 名字，像 field一、field2 等，若是字段在代碼中歷來也不會被用到，那麼能夠命名它爲 _。
結構體類型和字段的命名遵循可見性規則，因此可能存在一個結構體類型的某些字段是導出的，而另外一些沒有導出。
結構體的字段能夠是任何類型，甚至是結構體自己，也能夠是函數或者接口。能夠聲明結構體類型的一個變量，而後像下面這樣給它的字段賦值：

var s T
s.a = 5
s.b = 8

數組也能夠看做是一種結構體類型，不過它使用下標而不是具名的字段

二，初始化

方式一：經過 var 聲明結構體

在 Go 語言中當一個變量被聲明的時候，系統會自動初始化它的默認值，好比 int 被初始化爲 0，指針爲 nil。
var 聲明一樣也會爲結構體類型的數據分配內存，因此咱們才能像上一段代碼中那樣，在聲明瞭 var s T 以後就能直接給他的字段進行賦值

方式二：使用 new

使用 new 函數給一個新的結構體變量分配內存，它返回指向已分配內存的指針：var t *T = new(T)。

type struct1 struct {
    i1 int
    f1 float32
    str string
}

func main() {
    ms := new(struct1)
    ms.i1 = 10
    ms.f1 = 15.5
    ms.str= "Chris"

    fmt.Printf("The int is: %d\n", ms.i1)
    fmt.Printf("The float is: %f\n", ms.f1)
    fmt.Printf("The string is: %s\n", ms.str)
    fmt.Println(ms)
}

與面嚮對象語言相同，使用點操做符能夠給字段賦值：structname.fieldname = value。
一樣的，使用點操做符能夠獲取結構體字段的值：structname.fieldname。

方式三：使用字面量

type Person struct {
    name string
    age int
    address string
}

func main() {
    var p1 Person
    p1 = Person{"lisi", 30, "shanghai"}   //方式A
    p2 := Person{address:"beijing", age:25, name:"wangwu"} //方式B
    p3 := Person{address:"NewYork"} //方式C
}

在（方式A）中，值必須以字段在結構體定義時的順序給出。（方式B）是在值前面加上了字段名和冒號，這種方式下值的順序沒必要一致，而且某些字段還能夠被忽略掉，就想（方式C）那樣。
除了上面這三種方式外，還有一種初始化結構體實體更簡短和經常使用的方式，以下：

ms := &Person{"name", 20, "bj"}
ms2 := &Person{name:"zhangsan"}

&Person{a, b, c} 是一種簡寫，底層仍會調用 new()，這裏值的順序必須按照字段順序來寫，一樣它也可使用在值前面加上字段名和冒號的寫法（見上文的方式B，C）。

表達式 new(Type) 和 &Type{} 是等價的。

三，幾種初始化方式之間的區別

到目前爲止，咱們已經瞭解了三種初始化結構體的方式：

//第一種，在Go語言中，能夠直接以 var 的方式聲明結構體便可完成實例化
var t T
t.a = 1
t.b = 2

//第二種，使用 new() 實例化
t := new(T)

//第三種，使用字面量初始化
t := T{a, b}
t := &T{} //等效於 new(T)

使用 var t T 會給 t 分配內存，並零值化內存，可是這個時候的 t 的類型是 T
使用 new 關鍵字時 t := new(T)，變量 t 則是一個指向 T 的指針
從內存佈局上來看，咱們就能看出這三種初始化方式的區別：
使用 var 聲明：

使用 new 初始化：

使用結構體字面量初始化：

下面來看一個具體的例子

package main
import "fmt"

type Person struct {
 name string
 age int
}

func main() {
 var p1 Person
 p1.name = "zhangsan"
 p1.age = 18
 fmt.Printf("This is %s, %d years old\n", p1.name, p1.age)

 p2 := new(Person)
 p2.name = "lisi"
 p2.age = 20
 (*p2).age = 23 //這種寫法也是合法的
 fmt.Printf("This is %s, %d years old\n", p2.name, p2.age)

 p3 := Person{"wangwu", 25}
 fmt.Printf("This is %s, %d years old\n", p3.name, p3.age)
}

輸出：

This is zhangsan, 18 years old
This is lisi, 23 years old
This is wangwu, 25 years old

上面例子的第二種狀況，雖然 p2 是指針類型，但咱們仍然能夠像 p2.age = 23 這樣賦值，不須要像 C++ 中那樣使用 -> 操做符,Go 會自動進行轉換。
注意也能夠先經過 * 操做符來獲取指針所指向的內容，再進行賦值：(*p2).age = 23。

結構體的內存佈局

Go 語言中，結構體和它所包含的數據在內存中是以連續塊的形式存在的，即便結構體中嵌套有其餘的結構體，這在性能上帶來了很大的優點。不像 Java 中的引用類型，一個對象和它裏面包含的對象可能會在不一樣的內存空間中，這點和 Go 語言中的指針很像。下面的例子清晰地說明了這些狀況：

type Rect1 struct {Min, Max Point }
type Rect2 struct {Min, Max *Point }