Go基础编程：结构体

结构体(struct)是自定义方式形成新的数据类型，结构体是类型中带有成员的复合类型。Go 语言结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。来描述真实世界的实体和实体对应的各种属性。

结构体属性也叫 字段 或 成员 ,每个字段都有名称和类型，每个名称是唯一的。可以是任何类型，如普通类型、复合类型、函数、map、interface、struct等，所以我们可以理解为go语言中的“类”。

定义

结构体定义方式如下：

1. type name struct{ 
2.      fieldName1 type1 
3.      fieldName2 type2 
4.      ... 
5. } 

如下，定义User 结构体：

1. type User struct { 
2.      Name string 
3.      age  int 
4. } 

实例化

上面定义只是类型，就想是一个 int 一样，需要定义一个类型变量才可以使用，类似Java的类。

直接定义变量使用

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type User struct { 
8.      Name string 
9.      age  int 
10. } 
11. ​ 
12. func main() { 
13.      var user1 User //定义User 类型变量user 
14.      var user2 *User //类型指针，未分配内存，不能直接使用 
15.      fmt.Println(user1, user2) //{ 0} <nil> 
16. } 

定义默认成员变量

1. var user1 = User{Name: "abc"} 
2. fmt.Println(user1) 
3.  
4. func NewUser() *User { 
5.     return &User{Name:"abc",age:20} 
6. } 

使用内建函数 new() 分配内存返回类型变量指针

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

访问成员

使用 . 来访问

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

首字母大小写问题，成员大写表示包外可见(即面向对象的公有属性),小写包外不可见

零值：结构体的零值是 nil

初始值:结构体的初始值是非 nil 时，各成员对应类型的初始值

空结构体:空结构体就是没有字段的结构体，空结构体不占内存

1. package main 
2. ​ 
3. import ( 
4.      "fmt" 
5.      "unsafe" 
6. ) 
7. ​ 
8. func main() { 
9.      user1 := struct{}{} 
10.      user2 := struct{}{} 
11.      fmt.Printf("%p,%dn", &user1, unsafe.Sizeof(user1)) //0x585218,0 
12.      fmt.Printf("%p,%dn", &user2, unsafe.Sizeof(user2)) //0x585218,0 
13. } 

从上面可以看出空结构体内存地址和大小都是一样的。根据这个特性，使用空结构体可以作为信号量，起到信号作用但不占内存。如空结构体类型的 chan

匿名结构体

匿名结构体没有类型名称，无须通过 type 关键字定义就可以直接使用。

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

比较

如果结构体的全部成员都是 可以比较 的，且成员的 顺序 、 类型 、 数量 完全一样才可以比较，两个结构体将可以使用==或!=运算符进行比较。

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. func main() { 
8.      user1 := struct { 
9.      Name string 
10.      }{Name: "abc"} 
11.      user2 := struct { 
12.      Name string 
13.      }{Name: "abc"} 
14.      fmt.Println(user1 == user2) //true 
15. } 

成员名称不一样

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. func main() { 
8.      user1 := struct { 
9.      Name string 
10.      }{Name: "abc"} 
11.      user2 := struct { 
12.      name string 
13.      }{name: "abc"} 
14.      fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { name string }) 
15. } 

成员数量不一样

1. package main 
2. ​ 
3. import ( 
4.      "fmt" 
5. ) 
6. ​ 
7. func main() { 
8.      user1 := struct { 
9.      Name string 
10.      }{Name: "abc"} 
11.      user2 := struct { 
12.      Name string 
13.      age  int 
14.      }{Name: "abc"} 
15.      fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { Name string; age int }) 
16. } 

成员类型不能比较

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. func main() { 
8.      user1 := struct { 
9.      Name string 
10.      m    map[int]int 
11.      }{Name: "abc"} 
12.      user2 := struct { 
13.      Name string 
14.      m    map[int]int 
15.      }{Name: "abc"} 
16.      fmt.Println(user1 == user2) //invalid operation: user1 == user2 (struct containing map[int]int cannot be compared) 
17. } 

顺序不一样

1. package main 
2. ​ 
3. import ( 
4.      "fmt" 
5. ) 
6. ​ 
7. func main() { 
8.      user1 := struct { 
9.      Name string 
10.      age  int 
11.      }{Name: "abc"} 
12.      user2 := struct { 
13.      age  int 
14.      Name string 
15.      }{Name: "abc"} 
16.      fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string; age int } and struct { age int; Name string }) 
17. } 

其实整个结构体就是一个类型(如int)，成员顺序、类型这些不一样，整体的结构体就不一样，故对于强类型语言来说就是不能比较的，对应类型完全一样还需要注意成员是否是可以比较，如slice、map等

Go语言没有面向对象这个概念，但可以把结构体看做是一个类，可以实现面向对象的特性，如通过组合和嵌入实现继承

匿名字段

匿名字段是结构体没有显示的名字，是结构体嵌入一个或多个结构体，如下面

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

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type A struct { 
8.      Name string 
9.      B 
10. } 
11. type B struct { 
12.      Age int 
13.      Name string 
14. } 

访问成员变量

1. func main() { 
2.      var a = A{Name:"a",B:B{Name:"b",Age:20}} 
3.      fmt.Printf("%#vn", a) //main.A{Name:"", B:main.B{Age:0}} 
4.      fmt.Println(a.Name)  //a 
5.      fmt.Println(a.B.Name)  //b 
6.      fmt.Println(a.Age)  //20  
7. } 

只有一个成员名称的情况下，Go语法糖可以省略嵌入结构体

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

对应有多个相同名称的成员，不能省略，因为编译器不知道是哪个

1. type C struct { 
2.      A 
3.      B 
4. } 
5. ​ 
6. func main() { 
7.      var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}} 
8.      fmt.Println(c.Name) //ambiguous selector c.Name 
9. } 

正确做法是

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

组合

上面是没有名字的嵌入结构体，还可以给嵌入结构体命名,访问必须要带上具体的字段，不能省略。

1. package main 
2. ​ 
3. import ( 
4.      "fmt" 
5. ) 
6. ​ 
7. type A struct { 
8.      Btype B 
9. } 
10. type B struct { 
11.      Age int 
12.      Name string 
13. } 
14. ​ 
15. func main() { 
16.      var a = A{Btype:B{Name:"b",Age:20}} 
17.      fmt.Println(a.Name) //.Name undefined (type A has no field or method Name) 
18. } 

标签

如下面在字段后面用 `` 包起来的是标签，主要是通过反射来序列化和反序列化，具体由反射章节来讲。

1. type User struct { 
2.  Id int `json:"id"` 
3.  Account string `json:"account" form:"account"` 
4.  Nickname string `gorm:"nickname" json:"nickname" form:"nickname"` 
5. } 

方法

方法一般都是面向对象编程(OOP)的一个特性，Go语言的方法其实与一个值或变量关联的特殊的函数。这个值或变量叫做 接收者

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

接收者是自定义的类型

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type A struct {} //结构体 
8. ​ 
9. type B int  //int 
10. ​ 
11. func (a A) show()  { 
12.     fmt.Println("a............") 
13. } 
14. ​ 
15. func (b B) show()  { 
16.      fmt.Println("b............") 
17. } 
18. ​ 
19. func main() { 
20.      var a  A 
21.      var b  B 
22.      a.show() 
23.      b.show() 
24. } 

接收者不能直接用内置类型

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

接收者 值 可以是值类型或指针类型

1. package main 
2. ​ 
3. import ( 
4.      "fmt" 
5. ) 
6. ​ 
7. type A struct {} 
8. ​ 
9. type B struct {} 
10. ​ 
11. func (a A) show()  { //值类型 
12.      fmt.Println("a............") 
13. } 
14. ​ 
15. func (b *B) show()  { //指针类型 
16.      fmt.Println("b............") 
17. } 
18. ​ 
19. func main() { 
20.      var a  A 
21.      var b  B 
22.      a.show() 
23.      b.show() 
24. } 

对与 B 来说,下面两种调用方式是等价的，本质上他们都是一样的， b.show() 的写法是省略了 (&b) ,只不过由语法糖来补全

1. func main() { 
2.      var b  B 
3.      b.show() 
4.      (&b).show() 
5. } 

方法可以访问接收者自身的信息，如下

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type User struct { 
8.      Id int  
9.      Account string  
10.      Nickname string  
11. } 
12. ​ 
13. func (u User)show()  { 
14.     fmt.Println(u.Nickname) 
15. } 
16. ​ 
17. func main() { 
18.      var a  = User{Nickname:"测试"}  
19.      a.show() //测试 
20. } 

值类型接收者拷贝类型的全部，修改 不会 影响原数据;指针拷贝的是地址，修改 会 影响原数据

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type User struct { 
8.      Id int 
9.      Account string 
10.      Nickname string 
11. } 
12. ​ 
13. func (u User)show()  { 
14.     fmt.Println(u) 
15. } 
16. func (u User)setName1()  { 
17.      u.Nickname="值类型" 
18. } 
19. ​ 
20. func (u *User)setName2()  { 
21.      u.Nickname="指针类型" 
22. } 
23. ​ 
24. func main() { 
25.      var a  = User{Nickname:"测试"} 
26.      a.setName1() 
27.      a.show() 
28.      a.setName2() 
29.      a.show() 
30. } 

接受者 类型 本身不能为指针

1. package main 
2. ​ 
3. import ( 
4.     "fmt" 
5. ) 
6. ​ 
7. type A int  
8. ​ 
9. type B *int  //变量类型为指针 
10. ​ 
11. func (a A) show()  { 
12.      fmt.Println("a............") 
13. } 
14. ​ 
15. func (b B) show()  {  //invalid receiver type B (B is a pointer type) 
16.      fmt.Println("b............") 
17. }