Go語言基礎之結構體(春日篇)

前言

Hey，大家好呀，我是星期八，終於迎來了Go中最大一個知識點，結構體。

在Go，是沒有類和對象這個概念的。

是通過結構體的各種操作，模擬出來的像Java，Python之類的面向對象的。

回憶map

之前我們講過，Go語言的map是鍵值對的方式存儲數據的，就像這樣的。不記得的小夥伴請戳：一篇文章帶你了解Go語言基礎之map、Go語言基礎之map補充。

1. //方式一 
2. var student = map[string]string{ 
3.     "Name": "張三"， 
4.     "Age":  "18"， 
5. } 
6. //方式二 
7. var student2 = make(map[string]string， 10) 
8. student2["Name"] = "張三" 
9. student2["Age"] = "18" 

但是這樣，似乎有一個弊端，我不知道我有幾個key，並且value類型是固定的。

理論來說，key Age 對應的value應該是int類型，還有一些其他微妙的問題，通過map都是不太好解決的。

因為解決這些問題，所以，又引出了結構體這個類型。

前戲補充

在開始結構體之前呢，先看兩個奇怪的知識點。

自定義類型

1. type 自定義類型名 類型名 
2. 例: 
3. type NewInt int 

完整代碼

1. package main 
2.  
3. import "fmt" 
4.  
5. type NewInt int 
6.  
7. func main() { 
8.     var n1 NewInt = 1 
9.     fmt.Println(n1)//結果為1 
10. } 

如果要是理解的話，可以理解為NewInt包含了int的功能。

這裡可以把NewInt當作int來使用。

注:NewInt是一個新的類型，它包含int，並不等於int。

類型別名

代碼

1. type 類型別名 = 類型名 
2. 例: 
3. type Nint = int 

完整代碼

1. package main 
2.  
3. import "fmt" 
4.  
5. type Nint = int 
6.  
7. func main() { 
8.     var n1 Nint = 1 
9.     fmt.Println(n1)//1 
10. } 

自定義類型和類型別名區別

可能猛一看，感覺自定義類型和類型別名似乎一樣，但是其實是不太一樣的。

代碼

1. package main 
2.  
3. import "fmt" 
4.  
5. type Nint1 int   //自定義類型 
6. type Nint2 = int //類型別名 
7.  
8. func main() { 
9.     var n1 Nint1 = 1 
10.     var n2 Nint2 = 1 
11.     fmt.Printf("n1類型:%T，n2類型:%T"， n1， n2) 
12. } 

執行結果。

結論:自定義類型真的是自定義類型，類型都變了，類型別名只是類型名變了，但是本質沒變。

結構體

Go語言的結構體，相當Java，Python等語言中的類，已經不再是簡簡單單的結構體那麼簡單了。

結構體屬於基本數據類型。

內存圖大概如下。

結構體定義

定義結構體需要用到關鍵字type和struct。

語法

1. type 結構體名 struct { 
2.     欄位1 欄位類型1 
3.     欄位2 欄位類型2 
4.     ... 
5. } 

示例，通過結構體描述一個學生。

1. type Student struct { 
2.     Name   string 
3.     Age    int 
4.     Height int 
5.     Weight int 
6.     phone string 
7. } 

注:如果欄位類型是相同的，可以寫在同一行。

1. type Student struct { 
2.   Name                string 
3.   Age， Height， Weight int 
4.   phone               string 
5. } 

結構體初始化

方式一，賦值時初始化

1. func main() { 
2.   var s1 = Student{ 
3.     Name:   "張三"， 
4.     Age:    18， 
5.     Height: 180， 
6.     Weight: 120， 
7.     phone:  "6666666"， 
8.   } 
9.   fmt.Println(s1) 
10. } 

方式二，先聲明，後賦值

1. func main() { 
2.   var s1 Student 
3.   s1.Name = "張三" 
4.   s1.Age = 18 
5.   s1.Height = 180 
6.   s1.Weight = 120 
7.   s1.phone = "66666" 
8. } 

兩個執行結果。

匿名結構體

有時候我們的函數可能會要求傳入一個結構體，但是你又不想定義，就想臨時用一下，趕緊傳參得了。

這時候可以考慮匿名結構體。

方式一，先聲明，後賦值

1. func main() { 
2.   var car struct { 
3.     Name   string; 
4.     CarNum string 
5.   } 
6.   car.Name = "QQ" 
7.   car.CarNum = "京6666" 
8.   fmt.Println(car) //{QQ 京6666} 
9. } 

方式二，聲明+初始化

1. func main() { 
2.   var car = struct { 
3.     Name   string; 
4.     CarNum string 
5.   }{ 
6.     Name:   "QQ"， 
7.     CarNum: "京6666"， 
8.   } 
9.  
10.   fmt.Println(car) //{QQ 京6666} 
11. } 

兩個執行結果。

通過&方式初始化結構體

通過&的方式初始化，性能會提高一點，因為返回的是第一個的指針。

但是操作過程跟上述一樣，Go已經封裝好了。

代碼

1. func main() { 
2.   //方式一，等於一個空&結構體在賦值 
3.   var s1 = &Student{} 
4.   s1.Name = "張三" 
5.   //... 
6.   //方式二，直接賦值 
7.   var s2 = &Student{ 
8.     Name:   ""， 
9.     Age:    0， 
10.     Height: 0， 
11.     Weight: 0， 
12.     phone:  ""， 
13.   } 
14.   //方式三不可以 
15.   //var s3 &Student//error 
16. } 

使用&的方式基本跟原來一樣，但是方式三不行。

&初始化結構體函數注意事項

如果使用&的方式，那函數參數也要變一下的。

1. package main 
2.  
3. import "fmt" 
4.  
5. type Student struct { 
6.   Name                string 
7.   Age， Height， Weight int 
8.   phone               string 
9. } 
10.  
11. func sayStudent1(s Student) { 
12.   fmt.Println(s) 
13. } 
14. func sayStudent2(s *Student) { 
15.   //如果穿的是結構體地址，那麼接收就需要用* 
16.   fmt.Println(s) 
17. } 
18. func main() { 
19.   var s1 = Student{ 
20.     Name:   "111"， 
21.     Age:    0， 
22.     Height: 0， 
23.     Weight: 0， 
24.     phone:  "1111"， 
25.   } 
26.   var s2 = &Student{ 
27.     Name:   "2222"， 
28.     Age:    0， 
29.     Height: 0， 
30.     Weight: 0， 
31.     phone:  "2222"， 
32.   } 
33.   sayStudent1(s1) 
34.   sayStudent2(s2) 
35. } 

執行結果。

關於結構體默認值

代碼

1. func main() { 
2.   var s1 = Student{} 
3.   fmt.Println(s1) 
4. } 

執行結果。

在操作結構體時，即使沒有賦值，也會有默認值，所以不用擔心會報錯。

int默認值是0，string默認值是""，等。

總結

上述我們學習了Go語言基礎的結構體，先是回憶了map，map的優缺點，然後引入結構體。

講述了結構體如何創建，賦值，什麼是匿名結構體，直接通過&賦值結構體等。

本文轉載自微信公眾號「Go語言進階學習」，可以通過以下二維碼關注。轉載本文請聯繫Go語言進階學習公眾號。

【編輯推薦】

【責任編輯：

武曉燕

TEL：[phone]】

點讚 0