struct 結構體【GO 基礎】

〇、前言

雖然 Go 語言中沒有「類」的概念，也不支援「類」的繼承等物件導向的概念，但是可以通過結構體的內嵌，再配合介面，來實現物件導向，甚至具有更高的擴充套件性和靈活性。那麼本文就將詳細看下怎麼使用結構體。

一、結構體的定義和範例化

Go 語言中的基礎資料型別可以表示一些事物的基本屬性，但是當想要表達一個事物的全部或部分屬性時，這時候再用單一的基本資料型別明顯就無法滿足需求了。

Go 語言提供了一種自定義資料型別，可以封裝多個基本資料型別，這種資料型別叫結構體 struct。通過 struct 可以封裝自己所需的各種複雜型別。

1.1 什麼叫做自定義型別和型別別名？

在詳解結構體之前，需要先了解兩個概念，到底什麼叫做自定義型別和型別別名？

【自定義型別】

在 Go 語言中有一些基本的資料型別，如 string、整型、浮點型、布林等資料型別，Go 語言中可以使用 type 關鍵字來定義自定義型別。

自定義型別是定義了一個全新的型別。我們可以基於內建的基本型別定義，也可以通過 struct 定義。

type MyInt int // 新定義一個型別 MyInt，以 int 型別為參照

通過 type 關鍵字的定義，MyInt 就是一種新的型別，它具有 int 的特性。

【型別別名】

型別別名是 Go1.9 版本新增的新功能。

型別別名規定：TypeAlias 只是 Type 的別名，本質上 TypeAlias 與 Type 是同一個型別。就像一個小孩子有自己的小名和戶口本的大名，都是指的同一個人。

type TypeAlias = Type

例如長江的 rune 和 byte 就是型別別名，他們的定義如下：

type byte = uint8
type rune = int32

【區別】

那麼它們之前的區別是啥呢？下面分別定義一個變數看下它們的型別：

package main

import "fmt"

// 自定義型別
type NewInt int

// 型別別名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	fmt.Printf("NewInt type of a : %T\n", a)
	fmt.Printf("MyInt  type of b : %T\n", b)
}

有輸出結果可知，自定義型別的 type 將變成新的名字 NewInt；型別別名 MyInt，則仍屬於基本的 int 型別。

1.2 結構體的定義

使用 type 和 struct 關鍵字來定義結構體。

type 型別名 struct {
    欄位名 欄位型別
    欄位名 欄位型別
    …
}
// 型別名：標識自定義結構體的名稱，在同一個包內不能重複
// 欄位名：表示結構體欄位名，結構體中的欄位名必須唯一
// 欄位型別：表示結構體欄位的具體型別

舉個例子，我們定義一個 Person（人）結構體：

type Person struct {
    name string
    city string
    age  int8
}
// 型別相同的欄位可以放到一起，如下：
type Person struct {
    name, city string
    age  int8
}

這樣我們就擁有了一個 Person 的自定義型別，它有 name、city、age 三個欄位，分別表示姓名、城市和年齡。這樣我們使用這個 person 結構體就能夠很方便的在程式中表示和儲存人資訊了。

語言內建的基礎資料型別是用來描述一個值的，而結構體是用來描述一組值的。比如一個人有名字、年齡和居住城市等，本質上是一種聚合型的資料型別。

1.3 結構體的範例化

只有當結構體範例化時，才會真正地分配記憶體。也就是必須範例化後才能使用結構體的欄位。

// 結構體範例化格式：
var 結構體範例名 結構體型別

下面是一個 Person 的範例：

package main

import "fmt"

type Person struct {
	name string
	city string
	age  int8
}

func main() {
	var person Person
	person.name = "中國"
	person.city = "北京"
	person.age = 18
	fmt.Printf("person.name = %v\n", person.name)
	fmt.Printf("person %%v   = %v\n", person)
	fmt.Printf("person %%#v  = %#v\n", person)
}

二、結構體的使用

2.1 匿名結構體

結構體還可以直接用於臨時的或僅使用一次的場景中，不用宣告結構體的名稱，例如

package main

import (
	"fmt"
)

func main() {
	var user struct {
		Name string
		Age  int
	}
	user.Name = "張三"
	user.Age = 18
	fmt.Printf("%#v\n", user)
}

通過匿名結構體宣告得來的範例 user。

2.2 指標型別的結構體

當通過使用 new 關鍵字對結構體進行範例化後，得到的是結構體的地址。

另外，Go 語言中支援對結構體指標直接使用‘.’來存取結構體的成員。如下範例：

package main

import (
	"fmt"
)

type Person struct {
	name string
	city string
	age  int8
}

func main() {
	var p = new(Person) // 宣告結構體指標
    // p3 := &Person{} // 還可以通過 & 對結構體進行取地址操作，相當於對該結構體型別進行了一次 new 範例化操作
	p.name = "測試"
	p.age = 18
	p.city = "北京"
	fmt.Printf("%T\n", p) // 列印出型別
	fmt.Printf("p = %#v\n", p)
}

2.3 結構體的初始化

【宣告即初始化】

此時結構體的值均為預設零值：

package main

import (
	"fmt"
)

type Person struct {
	name string
	city string
	age  int8
}

func main() {
	// 宣告即初始化
	var p = new(Person)
	fmt.Printf("p = %#v\n", p)
}

【使用鍵值對初始化】

當某些欄位沒有初始值的時候，該欄位可以不寫。此時，沒有指定初始值的欄位的值就是該欄位型別的零值。

// 使用鍵值對初始化
p1 := Person{
    name: "張三",
    city: "北京",
    age:  18,
}
fmt.Printf("p1 = %#v\n", p1)
// 對結構體指標進行鍵值對初始化
p2 := &Person{
    name: "張三",
    city: "北京",
    age:  18,
}
fmt.Printf("p2 = %#v\n", p2)

【使用值的列表初始化】

初始化結構體的時候可以簡寫，也就是初始化的時候不寫鍵，直接寫值。

// 使用值的列表初始化
p3 := &Person{
    "張三",
    "北京",
    18,
}
fmt.Printf("p3 = %#v\n", p3)

注意，值列表需要滿足以下要求：

必須初始化結構體的所有欄位。
初始值的填充順序必須與欄位在結構體中的宣告順序一致。
該方式不能和鍵值初始化方式混用。

2.4 結構體的記憶體佈局

package main

import (
	"fmt"
)

type test struct {
	a int8
	b int8
	c int8
	d int8
}

func main() {
	n := test{
		1, 2, 3, 4,
	}
	fmt.Printf("n.a %p\n", &n.a)
	fmt.Printf("n.b %p\n", &n.b)
	fmt.Printf("n.c %p\n", &n.c)
	fmt.Printf("n.d %p\n", &n.d)
}

2.5 結構體的建構函式

Go 語言的結構體沒有建構函式，但可以自己實現。例如，下方的程式碼就實現了一個 Person 的建構函式。因為 struct 是值型別，如果結構體比較複雜的話，值拷貝效能開銷會比較大，所以該建構函式返回的是結構體指標型別。

package main

import (
	"fmt"
)

type Person struct {
	name string
	city string
	age  int8
}

func newPerson(name, city string, age int8) *Person {
	return &Person{
		name: name,
		city: city,
		age:  age,
	}
}

func main() {
	p9 := newPerson("張三", "測試", 90)
	fmt.Printf("%#v\n", p9)
}

2.6 方法和接收者

Go 語言中的方法（Method）是一種作用於特定型別變數的函數。這種特定型別變數叫做接收者（Receiver）。接收者的概念就類似於其他語言中的 this 或者 self。

func (接收者變數 接收者型別) 方法名(參數列) (返回引數) {
    函數體
}
// 接收者變數：接收者中的引數變數名在命名時，官方建議使用接收者型別名的第一個小寫字母，而不是 self、this 之類的命名
//     例如，Person 型別的接收者變數應該命名為 p，Connector 型別的接收者變數應該命名為 c 等
// 接收者型別：接收者型別和引數類似，可以是指標型別和非指標型別
// 方法名、參數列、返回引數：具體格式與函數定義相同

下面是一個簡單範例：

package main

import (
	"fmt"
)

// Person 結構體
type Person struct {
	name string
	age  int8
}

// NewPerson 建構函式
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// Dream Person 做夢的方法
func (p Person) Dream() {
	fmt.Printf("%s 的夢想是學好 Go 語言！\n", p.name)
}

func main() {
	p1 := NewPerson("張三同學", 25)
	p1.Dream()
}

方法與函數的區別是，函數不屬於任何型別，方法屬於特定的型別。

【比較指標型別和值型別的接收者的區別】

指標型別的接收者由一個結構體的指標組成，由於指標的特性，呼叫方法時修改接收者指標的任意成員變數，在方法結束後，修改都是有效的。

這種方式就十分接近於其他語言中物件導向中的 this 或者 self。例如我們為 Person 新增一個 SetAge 方法，來修改範例變數的年齡。

當方法作用於值型別接收者時，Go 語言會在程式碼執行時將接收者的值複製一份。在值型別接收者的方法中可以獲取接收者的成員值，但修改操作只是針對副本，無法修改接收者變數本身。

package main

import (
	"fmt"
)

// Person 結構體
type Person struct {
	name string
	age  int8
}

// NewPerson 建構函式
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// SetAge 設定p的年齡
// 使用指標接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}

// SetAge2 設定p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}

func main() {
	p1 := NewPerson("張三同學", 25)
	fmt.Println("修改前的 age ：", p1.age)
	p1.SetAge(18)
	fmt.Println("修改後的 age ：", p1.age)
	p1.SetAge2(20)
	fmt.Println("修改後的 age ：", p1.age)
}

使用指標型別的情況：

需要修改接收者中的值。
接收者是拷貝代價比較大的大物件。
保證一致性，如果有某個方法使用了指標接收者，那麼其他的方法也應該使用指標接收者。

【任意型別都可以新增方法】

比如下面範例程式碼，給自定義型別新增方法：

package main

import (
	"fmt"
)

// 自定義一個型別 MyInt，參考 int 型別
type MyInt int

// 為 MyInt 新增一個 SayHello 的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一個 int。")
}

func main() {
	var m1 MyInt
	m1.SayHello()
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1)
}

2.7 結構體允許包含匿名欄位

結構體允許其成員欄位在宣告時沒有欄位名而只有型別，這種沒有名字的欄位就稱為匿名欄位。

package main

import (
	"fmt"
)

// Person 結構體Person型別
type Person struct {
	string
	int
}

func main() {
	p1 := Person{
		"張三",
		18,
	}
	fmt.Printf("%#v\n", p1)
	fmt.Println(p1.string, p1.int)
}

匿名欄位預設採用型別名作為欄位名，結構體要求欄位名稱必須唯一，因此一個結構體中同種型別的匿名欄位只能有一個。

2.8 巢狀結構體

一個結構體中可以巢狀包含另一個結構體或結構體指標。

package main

import (
	"fmt"
)

// Address 地址結構體
type Address struct {
	Province string
	City     string
}

// User 使用者結構體
type User struct {
	Name    string
	Gender  string
	Address Address // 此處可以省略第二個 Address 以匿名型別方式
}

func main() {
	user1 := User{
		Name:   "張三",
		Gender: "女",
		Address: Address{
			Province: "北京",
			City:     "北京",
		},
	}
	fmt.Printf("user1 = %#v\n", user1)
}

當巢狀結構體內部存在相同的欄位名時，為了避免歧義需要指定具體的內嵌結構體的欄位，否則會提示異常。

2.9 結構體實現「繼承」

如下範例程式碼，通過巢狀匿名結構體實現繼承：

package main

import (
	"fmt"
)

// Animal 動物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s會動！\n", a.name)
}

// Dog 狗
type Dog struct {
	Feet    int8
	*Animal // 通過巢狀匿名結構體實現繼承
}

func (d *Dog) wang() {
	fmt.Printf("%s會汪汪汪~\n", d.name)
}

func main() {
	d1 := &Dog{
		Feet: 4,
		Animal: &Animal{ // 注意巢狀的是結構體指標
			name: "樂樂",
		},
	}
	d1.wang()
	d1.move()
}

注意：結構體中欄位大寫開頭表示可公開存取，小寫表示私有（僅在定義當前結構體的包中可存取）。

2.10 結構體與 JSON 序列化

JSON（JavaScript Object Notation）是一種輕量級的資料交換格式，易於人閱讀和編寫，同時也易於機器解析和生成。

JSON 鍵值對是用來儲存 JS 物件的一種方式，鍵/值對組合中的鍵名寫在前面並用雙引號 "" 包裹，使用冒號 : 分隔，然後緊接著值；多個鍵值之間使用英文 , 分隔。

package main

import (
	"encoding/json"
	"fmt"
)

// Student 學生
type Student struct {
	ID     int
	Gender string
	Name   string
}

// Class 班級
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 2; i++ { // 建立 2 個學生物件
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	// JSON 序列化：結構體-->JSON 格式的字串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n\n", data)
	// JSON 反序列化：JSON 格式的字串-->結構體
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

2.11 結構體標籤 Tag

Tag 是結構體的元資訊，可以在執行的時候通過反射的機制讀取出來。

Tag 在結構體欄位的後方定義，由一對反引號包裹起來，具體的格式如下：

`key1:"value1" key2:"value2"`

結構體標籤由一個或多個鍵值對組成。鍵與值使用冒號分隔，值用雙引號括起來。鍵值對之間使用一個空格分隔。

注意事項：為結構體編寫 Tag 時，必須嚴格遵守鍵值對的規則。結構體標籤的解析程式碼的容錯能力很差，一旦格式寫錯，編譯和執行時都不會提示任何錯誤，通過反射也無法正確取值。例如，不要在 key 和 value 之間新增空格。

例如我們為 Student 結構體的每個欄位定義 json 序列化時使用的 Tag：

package main

import (
	"encoding/json"
	"fmt"
)

// Student 學生
type Student struct {
	ID     int    `json:"id"` // 通過指定 tag 實現 json 序列化該欄位時的 key
	Gender string // json 序列化是預設使用欄位名作為 key
	name   string // 全小寫字母，表示私有不能被 json 包存取
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "女",
		name:   "張三",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data)
}

2.12 刪除 map 型別的結構體子項

package main

import "fmt"

type student struct {
	id   int
	name string
	age  int
}

func main() {
	ce := make(map[int]student)
	ce[1] = student{1, "張三", 22}
	ce[2] = student{2, "李四", 23}
	fmt.Println(ce)
	delete(ce, 2)
	fmt.Println(ce)
}

參考：http://www.topgoer.com/go%E5%9F%BA%E7%A1%80/%E7%BB%93%E6%9E%84%E4%BD%93.html