（十四）Golang基礎之結構體

阿新 • • 發佈：2022-05-05

Go語言中沒有“類”的概念，也不支援“類”的繼承等面向物件的概念，Go語言中通過結構體的內嵌在配置介面比面向物件具有更高的擴充套件性和靈活性。

類型別名和自定義型別

一、自定義型別

在Go語言中有一些基本色資料型別，如string、整型、浮點型、布林等資料型別，Go語言中可以使用type關鍵字來定義自定義型別。
自定義型別是定義了一個全新的型別。物品們可以基於內建的基本型別定義，也可以通過struct定義，例如：

//將MyInt定義為int型別
type MyInt int

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

二、類型別名

類型別名是Go1.9版本新增的新功能。
類型別名規定：
TypeAlias只是Type的別名，本質上TypeAlias與Type是同一個型別。就像一個孩子小時候有小名、乳名，上學後用學名，英語老師又會給他起英文名，但這些名字都指的是他本人。

Type TypeAlias = type

我們之前見過的rune和byte就是類型別名，他們的定義如下：

type byte = uint8
type rune = uing32

三、類型別名與自定義型別定義

表面上看只有一個等號的差異，我們通過下面的這段程式碼來理解他們之間的區別：

//型別定義
type NewInt int
//類型別名
type MyInt = int
func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}

結果顯示a的型別是main.NewInt，表示main包下定義的NewInt型別。b的型別是int。MyInt型別只會在程式碼中存在，編譯完成時並不會有MyInt型別。

結構體

Go語言中的基礎資料型別可以表示一些事物的基本屬性，但是當我們想表達一個事物的全部或部分屬性時，這時候再用單一的基本資料型別明顯就無法滿足需求了，Go語言提供了一種自定義資料型別，可以封裝多個基本資料型別，這種資料型別叫結構體，英文名稱struct。也就是我們可以通過struct來定義自己的型別了。
Go語言中通過struct來實現面向物件

四、結構體定義

使用type和struct關鍵字來定義結構體，具體程式碼格式入下：

Type 型別名 struct {
    欄位名  欄位型別
    欄位名  欄位型別
    。。。
}

其中：

型別名：標識自定義結構體的名稱，在同一個包內不能重複。
欄位名：表示結構體欄位名。結構體中的欄位名必須唯一。
欄位型別：表示結構體欄位的具體型別。
舉個例子，我們定義一個Person(人)結構體，程式碼如下：

type person struct {
	name string
	city string
	age  int8
}

同樣型別的欄位也可以寫在一行，

type person1 struct {
	name, city string
	age        int8
}

這樣我們就擁有了一個person的自定義型別，它有name、city、age三個欄位，分別表示姓名、城市和年兩。這樣我們使用這個person結構體就能夠很方便的在程式中表示和儲存人資訊了。
語言內建的基礎資料型別是用來描述一個值的，而結構體是用來描述一組值。比如一個人有名字、年齡和居住城市等，本質上是一種聚合型別的資料型別。

五、結構體例項化

只有當結構體例項化時，才會真正地分配記憶體。也就是必須例項化後才能使用結構體的欄位。
結構體本身也是一種型別，我們可以像宣告內建型別一樣使用var關鍵字宣告結構體型別。

var 結構體例項 結構體型別

1、基本例項化

舉個例子

type person struct {
	name string
	city string
	age  int8
}
func main() {
	var p1 person
	p1.name = "沙河娜扎"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

我們通過.來訪問結構體的欄位（成員變數），例如p1.name和p1.age等。

2、匿名結構體

在定義一些臨時資料結構等場景下還可以使用匿名機構體

package main
     
import (
    "fmt"
)
     
func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

3、建立指標型別結構體

我們還可以通過使用new關鍵字對結構體進行例項化，得到的是結構體的地址。格式如下：

var p2 = new(person)
fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

從列印的結果中我們可以看出p2是一個結構體指標。
需要注意的是在Go語言中支援對結構體指標直接使用.來訪問結構體的成員。

var p2 = new(person)
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

4、取結構體的地址例項化

使用&對結構體進行取地址操作相當於對該結構體型別進行了一次new例項化操作。

p3 := &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "七米"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}
p3.name = "七米"其實在底層是(*p3).name = "七米"，這是Go語言幫我們實現的語法糖。

六、結構體初始化

沒有初始化的結構體，其成員變數都是對應其型別的零值。

type person struct {
	name string
	city string
	age  int8
}
func main() {
	var p4 person
	fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}

1、使用鍵值對初始化

使用鍵值對對結構體進行初始化時，鍵對應結構體的欄位，值對應該欄位的初始值。

p5 := person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也可以對結構體指標進行鍵值對初始化，例如：

p6 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

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

p7 := &person{
	city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

2、使用值的列表初始化

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

p8 := &person{
	"沙河娜扎",
	"北京",
	28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"沙河那咋", city:"北京", age:19}

使用這種格式初始化時，需要注意：

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

七、結構體記憶體佈局

結構體佔用一塊連續的記憶體。

type test struct {
	a int8
	b int8
	c int8
	d int8
}
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)
輸出：
n.a 0xc0000a0060
n.b 0xc0000a0061
n.c 0xc0000a0062
n.d 0xc0000a0063

1、空結構體

空結構體是不佔用空間的。

var v struct{}
fmt.Println(unsafe.Sizeof(v))  // 0

八、面試題

請問下面程式碼的執行結果是什麼？

type student struct {
	name string
	age  int
}
func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "小王子", age: 18},
		{name: "娜扎", age: 23},
		{name: "大王八", age: 9000},
	}
for _, stu := range stus {
		m[stu.name] = &stu
	}
	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}

九、建構函式

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

func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}
呼叫建構函式
p9 := newPerson("張三", "沙河", 90)
fmt.Printf("%#v\n", p9) //&main.person{name:"張三", city:"沙河", age:90}

十、方法和接收者

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

func (接收者變數 接收者型別) 方法名(引數列表) (返回引數) {
    函式體
}

其中，

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

舉個例子：

//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()
}

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

1、指標型別的接收者

指標型別的接收者由一個結構體的指標組成，由於指標的特性，呼叫方法時修改接收者指標的任意成員變數，在方法結束後，修改都是有效的。這種方式就十分接近於其他語言中面向物件中的this或者self。例如我們為Person新增一個SetAge方法，來修改例項變數的年齡。

// SetAge 設定p的年齡
// 使用指標接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}
呼叫該方法：
func main() {
	p1 := NewPerson("小王子", 25)
	fmt.Println(p1.age) // 25
	p1.SetAge(30)
	fmt.Println(p1.age) // 30
}

2、值型別的接收者

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

// SetAge2 設定p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}
func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
	fmt.Println(p1.age) // 25
	p1.SetAge2(30) // (*p1).SetAge2(30)
	fmt.Println(p1.age) // 25
}

3、什麼時候應該使用指標型別接收者

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

十一、任意型別新增方法

在Go語言中，接收者的型別可以是任何型別，不僅僅是結構體，任何型別都可以擁有方法。舉個例子，我們基於內建的int型別使用type關鍵字可以定義新的自定義型別，然後為我們的自定義型別新增方法。

//MyInt 將int定義為自定義MyInt型別
type MyInt int
//SayHello 為MyInt新增一個SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一個int。")
}
func main() {
	var m1 MyInt
	m1.SayHello() //Hello, 我是一個int。
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事項：非本地型別不能定義方法，也就是說我們不能給別的包的型別定義方法。

十二、結構體匿名欄位

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

//Person 結構體Person型別
type Person struct {
	string
	int
}
func main() {
	p1 := Person{
		"小王子",
		18,
	}
	fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}
	fmt.Println(p1.string, p1.int) //北京 18
}

注意：這裡匿名欄位的說法並不代表沒有欄位名，而是預設會採用型別名作為欄位名，結構體要求欄位名稱必須唯一，因此一個結構體中同種型別的匿名欄位只能有一個。

十三、巢狀結構體

一個結構體中可以巢狀包含另一個結構體或結構體指標，就像下面的示例程式碼那樣。

//Address 地址結構體
type Address struct {
	Province string
	City     string
}
//User 使用者結構體
type User struct {
	Name    string
	Gender  string
	Address Address
}
func main() {
	user1 := User{
		Name:   "小王子",
		Gender: "男",
		Address: Address{
			Province: "山東",
			City:     "威海",
		},
	}
	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

1、巢狀匿名欄位

上面user結構體中巢狀的Address結構體也可以採用匿名欄位的方式，例如：

//Address 地址結構體
type Address struct {
	Province string
	City     string
}
//User 使用者結構體
type User struct {
	Name    string
	Gender  string
	Address //匿名欄位
}
func main() {
	var user2 User
	user2.Name = "小王子"
	user2.Gender = "男"
	user2.Address.Province = "山東"    // 匿名欄位預設使用型別名作為欄位名
	user2.City = "威海"                // 匿名欄位可以省略
	fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

2、巢狀結構體的欄位名衝突

巢狀結構體內部可能存在相同的欄位名。在這種情況下為了避免歧義需要通過指定具體的內嵌結構體欄位名。

//Address 地址結構體
type Address struct {
	Province   string
	City       string
	CreateTime string
}
//Email 郵箱結構體
type Email struct {
	Account    string
	CreateTime string
}
//User 使用者結構體
type User struct {
	Name   string
	Gender string
	Address
	Email
}
func main() {
	var user3 User
	user3.Name = "沙河娜扎"
	user3.Gender = "男"
	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
	user3.Address.CreateTime = "2000" //指定Address結構體中的CreateTime
	user3.Email.CreateTime = "2000"   //指定Email結構體中的CreateTime
}

十四、結構體的"繼承"

Go語言中使用結構體也可以實現其他程式語言中面向物件的繼承。

//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() //樂樂會動！
}

十五、結構體欄位的可見性

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

十六、結構體與JSON序列化

JSON(JavaScript Object Notation) 是一種輕量級的資料交換格式。易於人閱讀和編寫。同時也易於機器解析和生成。JSON鍵值對是用來儲存JS物件的一種方式，鍵/值對組合中的鍵名寫在前面並用雙引號""包裹，使用冒號:分隔，然後緊接著值；多個鍵值之間使用英文,分隔。

//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 < 10; i++ {
		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", data)
	//JSON反序列化：JSON格式的字串-->結構體
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

十七、結構體標籤（Tag）

Tag是結構體的元資訊，可以在執行的時候通過反射的機制讀取出來。 Tag在結構體欄位的後方定義，由一對反引號包裹起來，具體的格式如下：

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

結構體tag由一個或多個鍵值對組成。鍵與值使用冒號分隔，值用雙引號括起來。同一個結構體欄位可以設定多個鍵值對tag，不同的鍵值對之間使用空格分隔。
注意事項：為結構體編寫Tag時，必須嚴格遵守鍵值對的規則。結構體標籤的解析程式碼的容錯能力很差，一旦格式寫錯，編譯和執行時都不會提示任何錯誤，通過反射也無法正確取值。例如不要在key和value之間新增空格。
例如我們為Student結構體的每個欄位定義json序列化時使用的Tag：

//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) //json str:{"id":1,"Gender":"男"}
}

十八、結構體和方法補充知識點

因為slice和map這兩種資料型別都包含了指向底層資料的指標，因此我們在需要複製它們時要特別注意。我們來看下面的例子：

type Person struct {
	name   string
	age    int8
	dreams []string
}
func (p *Person) SetDreams(dreams []string) {
	p.dreams = dreams
}
func main() {
	p1 := Person{name: "小王子", age: 18}
	data := []string{"吃飯", "睡覺", "打豆豆"}
	p1.SetDreams(data)
// 你真的想要修改 p1.dreams 嗎？
	data[1] = "不睡覺"
	fmt.Println(p1.dreams)  // ?
}

正確的做法是在方法中使用傳入的slice的拷貝進行結構體賦值。

func (p *Person) SetDreams(dreams []string) {
	p.dreams = make([]string, len(dreams))
	copy(p.dreams, dreams)
}

同樣的問題也存在於返回值slice和map的情況，在實際編碼過程中一定要注意這個問題。