Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。

Go语言中通过struct来实现面向对象。

结构体的定义

基本结构体

使用type和struct来定义结构体，基本语法如下：

  1. type 类型名 struct{
  2.     字段名 字段类型
  3.     字段名 字段类型
  4. }

其中：

  • 类型名：标识自定义结构体的名称，在同一个包内不能重复。
  • 字段名：表示结构体字段名。结构体中的字段名必须唯一。
  • 字段类型：表示结构体字段的具体类型。

比如，定义一个Person的结构体：

  1. type Person struct{
  2.     name string
  3.     age int
  4. }

匿名结构体

在定义一些临时数据结构的时候可以用匿名结构体，基本语法如下：

  1. var 类型名 struct{
  2.     字段名 字段类型
  3.     字段名 字段类型
  4. }

和基本结构体相比，匿名结构体是用var来声明匿名结构体。

比如定义下面匿名结构体：

  1. var user struct{
  2.     name string
  3.     age int
  4. }

结构体实例化

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。

  1. var 结构体实例 结构体类型

基本实例化

示例如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     var joker person
  13.     joker.name = "Joker"
  14.     joker.age = 18
  15.     fmt.Println(joker)
  16. }

我们通过.来访问结构体的字段（成员变量）,例如joker.name和joker.age等。

实例化为指针类型结构体

我们可以通过new关键字对结构体进行实例化，得到的是结构体的地址。如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     var p2 = new(person)
  13.     fmt.Printf("%T\n", p2) // *main.Person
  14. }

从输出结果来看p2是一个指针类型。

指针类型的结构体依然是用.来访问结构体的成员，如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  13.     var p2 = new(person)
  14.     fmt.Printf("%T\n", p2) // *main.Person
  15.     p2.name = "乔克"
  16.     p2.age = 20
  17.     fmt.Printf("%v\n", p2) // &{乔克 20}
  18.     fmt.Println(*p2)       // {乔克 20}
  19. }

取结构体的地址除了使用new方法外还可以使用&。如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     p3 := &person{}
  13.     fmt.Printf("%T\n", p3)
  14.     p3.name = "Jim"
  15.     p3.age = 45
  16.     fmt.Printf("%v\n", p3) // &{Jim 45}
  17.     fmt.Println(*p3)       // {Jim 45}
  18. }

结构体初始化

没有初始化的结构体，其成员变量都是零值，如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     var p4 person
  13.     fmt.Printf("p4:%##v\n", p4) //p4:main.person{name:"", age:0}
  14. }

如果要进行初始化，有以下几种。

使用键值对初始化

使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     p5 := person{
  13.         name: "小白",
  14.         age:  18,
  15.     }
  16.     fmt.Printf("p5:%#v\n", p5) //p5:main.person{name:"小白", age:18}
  17. }

也可以对结构体指针进行键值对初始化，如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  12.     p6 := &person{
  13.         name: "小青",
  14.         age:  100,
  15.     }
  16.     fmt.Printf("p6:%#v\n", p6) //p6:&main.person{name:"小青", age:100}
  17. }

如果某些键值对不需要，我们可以省略，该键值对就会是默认零值，如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  13.     p7 := person{
  14.         name: "小灰",
  15.     }
  16.     fmt.Printf("p7:%#v\n", p7) //p7:main.person{name:"小灰", age:0}
  17. }

使用值的列表初始化

初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值。如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func main() {
  11.     // 结构体实例化
  13.     p8 := person{
  14.         "小红",
  15.         23,
  16.     }
  17.     fmt.Printf("p8:%#v\n", p8) //p8:main.person{name:"小红", age:23}
  18. }

使用这种格式初始化时，需要注意：

  1. 必须初始化结构体的所有字段。
  2. 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
  3. 该方式不能和键值初始化方式混用。

结构体内存布局

结构体在内存中是占用一块连续得内存，我们这里以int8类型为例，因为int8类型在内存中刚好占一个字节。

如下定义一个结构体，然后打印其内存指针。

  1. package main
  3. import "fmt"
  5. // 定义一个全是int8类型得结构体
  6. type memTest struct {
  7.     a int8
  8.     b int8
  9.     c int8
  10.     d int8
  11. }
  13. func main() {
  14.     // 初始化结构体
  15.     s := memTest{1, 2, 3, 4}
  16.     fmt.Printf("s.a:%p\n", &s.a) //s.a:0xc000064068
  17.     fmt.Printf("s.b:%p\n", &s.b) //s.b:0xc000064069
  18.     fmt.Printf("s.c:%p\n", &s.c) //s.c:0xc00006406a
  19.     fmt.Printf("s.d:%p\n", &s.d) //s.d:0xc00006406b
  20. }

构造函数

Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func newPersion(name string, age int) *person {
  11.     return &person{
  12.         name: name,
  13.         age:  age,
  14.     }
  15. }
  17. func main() {
  18.     // 调用构造函数
  19.     p9 := newPersion("小乖乖", 20)
  20.     fmt.Printf("p9:%#v\n", p9)
  21. }

构造函数的命名规则：约定成俗是new+结构体名，如上newPerson。

方法和接收者

Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。

方法的定义格式如下：

  1. func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
  2.     函数体
  3. }

其中，

  • 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
  • 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
  • 方法名、参数列表、返回参数：具体格式与函数定义相同。

例如：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. // 构造函数
  11. func newPersion(name string, age int) *person {
  12.     return &person{
  13.         name: name,
  14.         age:  age,
  15.     }
  16. }
  18. //  构造方法
  19. func (p person) buyHouse(name string) {
  20.     fmt.Printf("%s买房子了", name)
  21. }
  23. func main() {
  24.     // 结构体实例化
  25.     p9 := newPersion("小乖乖", 20)
  26.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:20}
  27.     p9.buyHouse(p9.name)       //小乖乖买房子了
  28. }

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。

指针类型的接收者

由于结构体是值类型，在给函数传参的时候是值传递，相当于ctrl+c和ctrl+v，其修改只在当前方法中有效。如果我们要使其在方法结束后依然有效，就需要使用到指针类型，因为其传递的是内存指针。

如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. // 构造函数
  11. func newPersion(name string, age int) *person {
  12.     return &person{
  13.         name: name,
  14.         age:  age,
  15.     }
  16. }
  18. //  构造方法
  19. func (p person) buyHouse() {
  20.     fmt.Printf("%s买房子\n", p.name)
  21. }
  23. // 指针类型的 接收者
  24. func (p *person) changeAge(age int) {
  25.     p.age = age
  26. }
  27. func main() {
  28.     // 结构体实例化
  30.     p9 := newPersion("小乖乖", 20)
  31.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:20}
  32.     p9.buyHouse()              //小乖乖买房子了
  33.     p9.changeAge(21)
  34.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:21}
  35. }

通过changeAge修改值对其本身p9也生效了。

值类型的接收者

我们现在定义一个值类型的接收者和上面的指针类型接收者做个对比。如下：

  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. // 构造函数
  11. func newPersion(name string, age int) *person {
  12.     return &person{
  13.         name: name,
  14.         age:  age,
  15.     }
  16. }
  18. //  构造方法
  19. func (p person) buyHouse() {
  20.     fmt.Printf("%s买房子\n", p.name)
  21. }
  23. // 指针类型的 接收者
  24. func (p *person) changeAge(age int) {
  25.     p.age = age
  26. }
  28. // 值类型的接收者
  29. func (p person) changeAge2(age int) {
  30.     p.age = age
  31. }
  33. func main() {
  34.     // 结构体实例化
  35.     p9 := newPersion("小乖乖", 20)
  36.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:20}
  37.     p9.buyHouse()              //小乖乖买房子了
  38.     p9.changeAge(21)
  39.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:21}
  40.     p9.changeAge2(100)
  41.     fmt.Printf("p9:%#v\n", p9) //p9:&main.person{name:"小乖乖", age:21}
  42. }

定义值类型的接收者的方法changeAge2，我们在调用后，输出p9，发现其实并没有改变。从上面就可以看出值类型和指针类型接收者的区别。

如何选择

  1. 需要修改接收者中的值
  2. 接收者是拷贝代价比较大的大对象
  3. 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。

任意类型添加方法

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

  1. //MyInt 将int定义为自定义MyInt类型
  2. type MyInt int
  4. //SayHello 为MyInt添加一个SayHello的方法
  5. func (m MyInt) SayHello() {
  6.     fmt.Println("Hello, 我是一个int。")
  7. }
  8. func main() {
  9.     var m1 MyInt
  10.     m1.SayHello() //Hello, 我是一个int。
  11.     m1 = 100
  12.     fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
  13. }

注意事项：

  • 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
  • 我们不能给内置的类型添加方法。

结构体的匿名字段

前面说过匿名就是没写名字，那么结构体的匿名字段就是在结构体中没写名字的字段。如下：

  1. // 定义匿名字段的结构体
  2. type test struct{
  3.     string
  4.     int
  5. }

匿名字段的结构体该如何使用呢？如下：

  1. package main
  3. import "fmt"
  5. // 定义匿名字段的结构体
  6. type test struct {
  7.     string
  8.     int
  9. }
  11. func main() {
  12.     // 声明结构体变量，并实例化
  13.     s1 := test{
  14.         "小黑",
  15.         500,
  16.     }
  17.     // 取变量中的值
  18.     fmt.Printf("%s - %d\n", s1.string, s1.int) //小黑 - 500
  19. }

声明匿名字段的结构体和通过值得列表得方式声明普通结构体类似，字段从上到下是什么类型就写什么类型。

在取变量中得值得时候直接使用类型名。可以理解为匿名字段默认就以类型名作为字段名。

既然匿名字段得结构体是直接用得类型，那么就可以想到在一个匿名字段结构体中的字段必须唯一，所以在一个结构体中同种类型的匿名字段只能有一个。

嵌套结构体

顾名思义，嵌套结构体就是在结构体中嵌套另一个结构体。如下：

  1. package main
  3. import "fmt"
  5. type address struct {
  6.     city   string
  7.     street string
  8. }
  10. type company struct {
  11.     city   string
  12.     street string
  13. }
  15. type person struct {
  16.     name string
  17.     age  int
  18.     addr address
  19.     comp company
  20. }
  22. func main() {
  23.     // 声明
  24.     p := person{
  25.         name: "小白",
  26.         age:  20,
  27.         addr: address{
  28.             city:   "重庆",
  29.             street: "观音桥",
  30.         },
  31.         comp: company{
  32.             city:   "重庆",
  33.             street: "大坪",
  34.         },
  35.     }
  36.     fmt.Printf("p:%#v\n", p) // p:main.person{name:"小白", age:20, addr:main.address{city:"重庆", street:"观音桥"}, comp:main.company{city:"重庆", street:"大坪"}}
  37. }

我们在person的结构体中嵌套了address和company结构体，这就是结构体的嵌套。

如果我们要取结构体中结构体的值，可以用如下方式：

  1. fmt.Printf("%s\n", p.addr.city)

嵌套匿名字段的结构体

结构体还可以嵌套匿名字段的结构体，如下：

  1. package main
  3. import "fmt"
  5. type address struct {
  6.     city   string
  7.     area   string
  8.     street string
  9. }
  11. type company struct {
  12.     city   string
  13.     street string
  14. }
  16. type person struct {
  17.     name string
  18.     age  int
  19.     address
  20.     company
  21. }
  23. func main() {
  24.     // 声明
  25.     p := person{
  26.         name: "小白",
  27.         age:  20,
  28.         address: address{
  29.             city:   "重庆",
  30.             area:   "江北区",
  31.             street: "观音桥",
  32.         },
  33.         company: company{
  34.             city:   "重庆",
  35.             street: "大坪",
  36.         },
  37.     }
  38.     fmt.Printf("p:%#v\n", p)
  39.     fmt.Printf("%s\n", p.area)
  40. }

结构体嵌套匿名字段结构体，如果没有字段冲突可以直接用语法糖的形式访问，如下：

  1. fmt.Printf("%s\n", p.area)

如果有字段冲突，就要用如下方式：

  1. fmt.Printf("%s\n",p.address.city)
  2. fmt.Printf("%s\n",p.company.city)

结构体的”继承”

在Go中没有继承这一说法，但是可以实现其他编程语言中面向对象中的继承。如下：

  1. package main
  3. import "fmt"
  5. // 定义一个animal结构体
  6. type animal struct {
  7.     name string
  8. }
  10. // 定义一个animal结构体的方法
  11. func (a *animal) run() {
  12.     fmt.Printf("%s是可以跑的\n", a.name)
  13. }
  15. // 定义一个dog结构体
  16. type dog struct {
  17.     *animal // 通过嵌套匿名结构体实现集成
  18.     age     int
  19. }
  21. // 定义一个dog结构体的方法
  22. func (d *dog) eat() {
  23.     fmt.Printf("%s可以吃东西\n", d.name)
  24. }
  26. func main() {
  27.     // 定义一个指针类型的dog
  28.     d := &dog{
  29.         animal: &animal{
  30.             name: "小黑",
  31.         },
  32.         age: 2,
  33.     }
  34.     d.run() // 可以调用animal的方法
  35.     d.eat() // 可以调用自己的方法
  36.     /*
  37.         输出：
  38.         小黑是可以跑的
  39.         小黑可以吃东西
  40.     */
  41. }

结构体字段的可见性

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。

如果结构体的的名字是大写字母开头，则需要在上面注释才不会出现警告信息，格式如下：

  1. // Dog 定义一个Dog的结构体
  2. type Dog struct{
  3.     name string
  4. }

结构体与JSON

其他语言都有JSON序列化和反序列化，比如python的json库。在Go语言也t有类似库，它是encoding/json。详情可以查看:[https://studygolang.com/pkgdoc]。

例子：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. // 定义一个animal结构体
  9. type animal struct {
  10.     name string
  11. }
  13. // 定义一个dog结构体
  14. type dog struct {
  15.     *animal // 通过嵌套匿名结构体实现集成
  16.     age     int
  17. }
  19. func main() {
  20.     // 声明结构体变量
  21.     d := &dog{
  22.         animal: &animal{
  23.             name: "小七",
  24.         },
  25.         age: 1,
  26.     }
  27.     // 进行JSON序列化：结构体 -> json
  28.     data, err := json.Marshal(d)
  29.     if err != nil {
  30.         fmt.Printf("结构体转换为JSON失败：%#v\n", err)
  31.     } else {
  32.         fmt.Printf("结构体 -> json：%#v\n", string(data)) //结构体 -> json："{}"
  33.     }
  34. }

上面的输出结果并不是我们想要的，这是为什么呢？

我们前面介绍过函数之间或者包之间的变量传递是值传递，我们是在json这个包里做的序列化，然后在我们main包进行使用，是拿不到json中的数据的，如果要拿到，则结构体中的字段名用大写，如下：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. // 定义一个animal结构体
  9. type animal struct {
  10.     Name string
  11. }
  13. // 定义一个dog结构体
  14. type dog struct {
  15.     *animal // 通过嵌套匿名结构体实现集成
  16.     Age     int
  17. }
  19. func main() {
  20.     // 声明结构体变量
  21.     d := &dog{
  22.         animal: &animal{
  23.             Name: "小七",
  24.         },
  25.         Age: 1,
  26.     }
  27.     // 进行JSON序列化：结构体 -> json
  28.     data, err := json.Marshal(d)
  29.     if err != nil {
  30.         fmt.Printf("结构体转换为JSON失败：%#v\n", err)
  31.     } else {
  32.         fmt.Printf("结构体 -> json：%#v\n", string(data)) //结构体 -> json："{\"Name\":\"小七\",\"Age\":1}"
  33.     }
  35. }

上面说的是序列化，那么反序列化就是从json文件转化为结构体，如下：

  1. // 自定义一个json数据
  2.     str1 := `{"animal":{"name":"小白"},"age":100}`
  3.     // 定义一个结构体接收数据
  4.     d1 := dog{}
  5.     // 将其转化为结构体
  6.     err = json.Unmarshal([]byte(str1), &d1)
  7.     if err != nil {
  8.         fmt.Printf("%#v\n", err)
  9.     }
  10.     fmt.Printf("%#v\n", d1)

注意：

  • 函数传参是值传递，所以给Unmarshal的接收变量得是指针变量

结构体标签

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。 Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：

  1. `key1:"value1" key2:"value2"`

结构体标签由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。键值对之间使用一个空格分隔。 注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

如下：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. // 定义一个animal结构体
  9. type animal struct {
  10.     Name string `json:"name"`
  11. }
  13. // 定义一个dog结构体
  14. type dog struct {
  15.     *animal     // 通过嵌套匿名结构体实现集成
  16.     Age     int `json:"age"`
  17. }
  19. func main() {
  20.     // 声明结构体变量
  21.     d := &dog{
  22.         animal: &animal{
  23.             Name: "小七",
  24.         },
  25.         Age: 1,
  26.     }
  27.     // 进行JSON序列化：结构体 -> json
  28.     data, err := json.Marshal(d)
  29.     if err != nil {
  30.         fmt.Printf("结构体转换为JSON失败：%#v\n", err)
  31.     } else {
  32.         fmt.Printf("结构体 -> json：%#v\n", string(data)) //结构体 -> json："{\"name\":\"小七\",\"age\":1}"
  33.     }
  34. }