結構體(struct)是自定義方式形成新的數據類型，結構體是類型中帶有成員的復合類型。Go 語言結構體是一種聚合的數據類型，是由零個或多個任意類型的值聚合成的實體。每個值稱為結構體的成員。來描述真實世界的實體和實體對應的各種屬性。

結構體屬性也叫 字段 或 成員 ,每個字段都有名稱和類型，每個名稱是唯一的。可以是任何類型，如普通類型、復合類型、函數、map、interface、struct等，所以我們可以理解為go語言中的“類”。

定義

結構體定義方式如下：

type name struct{ 
     fieldName1 type1 
     fieldName2 type2 
     ... 
} 

如下，定義User 結構體：

type User struct { 
     Name string 
     age  int 
} 

實例化

上面定義只是類型，就想是一個 int 一樣，需要定義一個類型變量才可以使用，類似Java的類。

直接定義變量使用

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type User struct { 
     Name string 
     age  int 
} 
​ 
func main() { 
     var user1 User //定義User 類型變量user 
     var user2 *User //類型指針，未分配內存，不能直接使用 
     fmt.Println(user1, user2) //{ 0} <nil> 
} 

定義默認成員變量

var user1 = User{Name: "abc"} 
fmt.Println(user1) 
 
func NewUser() *User { 
    return &User{Name:"abc",age:20} 
} 

使用內建函數 new() 分配內存返回類型變量指針

var user = new(User) 
fmt.Println(user) //&{ 0} 

訪問成員

使用 . 來訪問

var user User 
user.Name = "abc" 
user.age = 20 
fmt.Println(user) //{abc 20} 

首字母大小寫問題，成員大寫表示包外可見(即面向對象的公有屬性),小寫包外不可見

零值：結構體的零值是 nil

初始值:結構體的初始值是非 nil 時，各成員對應類型的初始值

空結構體:空結構體就是沒有字段的結構體，空結構體不占內存

package main 
​ 
import ( 
     "fmt" 
     "unsafe" 
) 
​ 
func main() { 
     user1 := struct{}{} 
     user2 := struct{}{} 
     fmt.Printf("%p,%dn", &user1, unsafe.Sizeof(user1)) //0x585218,0 
     fmt.Printf("%p,%dn", &user2, unsafe.Sizeof(user2)) //0x585218,0 
} 

從上面可以看出空結構體內存地址和大小都是一樣的。根據這個特性，使用空結構體可以作為信號量，起到信號作用但不占內存。如空結構體類型的 chan

匿名結構體

匿名結構體沒有類型名稱，無須通過 type 關鍵字定義就可以直接使用。

user := struct { 
     Name string 
 }{Name: "abc"} 
fmt.Println(user) //{abc} 

比較

如果結構體的全部成員都是 可以比較 的，且成員的 順序 、 類型 、 數量 完全一樣才可以比較，兩個結構體將可以使用==或!=運算符進行比較。

package main 
​ 
import ( 
    "fmt" 
) 
​ 
func main() { 
     user1 := struct { 
     Name string 
     }{Name: "abc"} 
     user2 := struct { 
     Name string 
     }{Name: "abc"} 
     fmt.Println(user1 == user2) //true 
} 

成員名稱不一樣

package main 
​ 
import ( 
    "fmt" 
) 
​ 
func main() { 
     user1 := struct { 
     Name string 
     }{Name: "abc"} 
     user2 := struct { 
     name string 
     }{name: "abc"} 
     fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { name string }) 
} 

成員數量不一樣

package main 
​ 
import ( 
     "fmt" 
) 
​ 
func main() { 
     user1 := struct { 
     Name string 
     }{Name: "abc"} 
     user2 := struct { 
     Name string 
     age  int 
     }{Name: "abc"} 
     fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { Name string; age int }) 
} 

成員類型不能比較

package main 
​ 
import ( 
    "fmt" 
) 
​ 
func main() { 
     user1 := struct { 
     Name string 
     m    map[int]int 
     }{Name: "abc"} 
     user2 := struct { 
     Name string 
     m    map[int]int 
     }{Name: "abc"} 
     fmt.Println(user1 == user2) //invalid operation: user1 == user2 (struct containing map[int]int cannot be compared) 
} 

順序不一樣

package main 
​ 
import ( 
     "fmt" 
) 
​ 
func main() { 
     user1 := struct { 
     Name string 
     age  int 
     }{Name: "abc"} 
     user2 := struct { 
     age  int 
     Name string 
     }{Name: "abc"} 
     fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string; age int } and struct { age int; Name string }) 
} 

其實整個結構體就是一個類型(如int)，成員順序、類型這些不一樣，整體的結構體就不一樣，故對于強類型語言來說就是不能比較的，對應類型完全一樣還需要注意成員是否是可以比較，如slice、map等

Go語言沒有面向對象這個概念，但可以把結構體看做是一個類，可以實現面向對象的特性，如通過組合和嵌入實現繼承

匿名字段

匿名字段是結構體沒有顯示的名字，是結構體嵌入一個或多個結構體，如下面

B直接嵌入A ，B是匿名字段

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type A struct { 
     Name string 
     B 
} 
type B struct { 
     Age int 
     Name string 
} 

訪問成員變量

func main() { 
     var a = A{Name:"a",B:B{Name:"b",Age:20}} 
     fmt.Printf("%#vn", a) //main.A{Name:"", B:main.B{Age:0}} 
     fmt.Println(a.Name)  //a 
     fmt.Println(a.B.Name)  //b 
     fmt.Println(a.Age)  //20  
} 

只有一個成員名稱的情況下，Go語法糖可以省略嵌入結構體

fmt.Println(a.B.Age) //20 
fmt.Println(a.Age)   //20 

對應有多個相同名稱的成員，不能省略，因為編譯器不知道是哪個

type C struct { 
     A 
     B 
} 
​ 
func main() { 
     var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}} 
     fmt.Println(c.Name) //ambiguous selector c.Name 
} 

正確做法是

func main() { 
     var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}} 
     fmt.Println(c.A.Name) //a 
     fmt.Println(c.B.Name) //b 
} 

組合

上面是沒有名字的嵌入結構體，還可以給嵌入結構體命名,訪問必須要帶上具體的字段，不能省略。

package main 
​ 
import ( 
     "fmt" 
) 
​ 
type A struct { 
     Btype B 
} 
type B struct { 
     Age int 
     Name string 
} 
​ 
func main() { 
     var a = A{Btype:B{Name:"b",Age:20}} 
     fmt.Println(a.Name) //.Name undefined (type A has no field or method Name) 
} 

標簽

如下面在字段后面用 `` 包起來的是標簽，主要是通過反射來序列化和反序列化，具體由反射章節來講。

type User struct { 
 Id int `json:"id"` 
 Account string `json:"account" form:"account"` 
 Nickname string `gorm:"nickname" json:"nickname" form:"nickname"` 
} 

方法

方法一般都是面向對象編程(OOP)的一個特性，Go語言的方法其實與一個值或變量關聯的特殊的函數。這個值或變量叫做 接收者

func ([typeName] 接收者) name (param) [return]{} 

接收者是自定義的類型

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type A struct {} //結構體 
​ 
type B int  //int 
​ 
func (a A) show()  { 
    fmt.Println("a............") 
} 
​ 
func (b B) show()  { 
     fmt.Println("b............") 
} 
​ 
func main() { 
     var a  A 
     var b  B 
     a.show() 
     b.show() 
} 

接收者不能直接用內置類型

func (c int) show()  {  //cannot define new methods on non-local type int 
    fmt.Println("b............") 
} 

接收者 值 可以是值類型或指針類型

package main 
​ 
import ( 
     "fmt" 
) 
​ 
type A struct {} 
​ 
type B struct {} 
​ 
func (a A) show()  { //值類型 
     fmt.Println("a............") 
} 
​ 
func (b *B) show()  { //指針類型 
     fmt.Println("b............") 
} 
​ 
func main() { 
     var a  A 
     var b  B 
     a.show() 
     b.show() 
} 

對與 B 來說,下面兩種調用方式是等價的，本質上他們都是一樣的， b.show() 的寫法是省略了 (&b) ,只不過由語法糖來補全

func main() { 
     var b  B 
     b.show() 
     (&b).show() 
} 

方法可以訪問接收者自身的信息，如下

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type User struct { 
     Id int  
     Account string  
     Nickname string  
} 
​ 
func (u User)show()  { 
    fmt.Println(u.Nickname) 
} 
​ 
func main() { 
     var a  = User{Nickname:"測試"}  
     a.show() //測試 
} 

值類型接收者拷貝類型的全部，修改 不會 影響原數據;指針拷貝的是地址，修改 會 影響原數據

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type User struct { 
     Id int 
     Account string 
     Nickname string 
} 
​ 
func (u User)show()  { 
    fmt.Println(u) 
} 
func (u User)setName1()  { 
     u.Nickname="值類型" 
} 
​ 
func (u *User)setName2()  { 
     u.Nickname="指針類型" 
} 
​ 
func main() { 
     var a  = User{Nickname:"測試"} 
     a.setName1() 
     a.show() 
     a.setName2() 
     a.show() 
} 

接受者 類型 本身不能為指針

package main 
​ 
import ( 
    "fmt" 
) 
​ 
type A int  
​ 
type B *int  //變量類型為指針 
​ 
func (a A) show()  { 
     fmt.Println("a............") 
} 
​ 
func (b B) show()  {  //invalid receiver type B (B is a pointer type) 
     fmt.Println("b............") 
}