【Golang】结构体详解

1、类型别名 && 自定义类型

Go语言中没有 “类” 的概念，也不支持 “类” 的继承等面向对象的概念
Go语言中通过结构体的内嵌 再配合 接口，达到比面向对象更高的扩展性和灵活性

1.1、自定义类型

在Go语言中有一些基本的数据类型，可以使用type关键字来定义自定义类型
自定义类型是定义了一个全新的类型，我们可以基于内置的基本类型定义，也可以通过struct定义

type MyInt int
type MyStruct struct {
	Name string
	Age  int
}
1
2
3
4
5

通过type关键字的定义，MyInt && MyStruct 就是一种新的类型

1.2、 类型别名

类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型

type TypeAlias = Type
//e.g
type byte = uint8
type rune = int32
1
2
3
4

1.3、二者的区别

类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别

//类型定义
type NewInt int

//类型别名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) 
	fmt.Printf("type of b:%T\n", b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型
b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型

总结：类型定义有新类型产生，类型别名没有新类型产生，并且在编译阶段被替换为原始类型

2、结构体

Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了

Go语言提供了一种自定义数据类型，可以封装多个基本数据类型 or 自定义类型，这种数据类型叫结构体，英文名称struct

2.1、结构体定义

使用type和struct关键字来定义结构体，具体代码格式如下：

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

注意：

• 类型名：表示自定义结构体的名称，同一个包内不允许重复
• 字段名：表示结构体字段的名称，在整个结构体内这个名称是唯一的
• 字段类型：表示结构体字段的具体类型，可以是基本数据类型，也可以是自定义类型

e.g:

type Person struct {
	Name string
	City string
	Age  int
}
1
2
3
4
5

上面代码表示：定义了一个自定义类型Person,由Name, City，Age三个字段组成

语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的，本质上是一种聚合型的数据类型

2.2、结构体实例化

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

结构体本身也是一种类型，我们可以像申明内置类型那样申明一个结构体

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

下面介绍结构体实例化的几种方式：

• 基本实例化

type Person struct {
	Name string
	City string
	Age  int
}

func main() {
	var person Person
	person.Name = "GGBond"
	person.Age = 18
	person.City = "深圳"

	fmt.Println(person)
	fmt.Printf("%+v\n", person)
	fmt.Printf("%#v\n", person)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 匿名结构体
  在定义一些临时数据结构等场景下还可以使用匿名结构体

func main() {
	var person struct {
		Name string
		Age  int
		City string
	}
	person.Name = "GGBond"
	person.Age = 18
	person.City = "深圳"

	fmt.Printf("%+v\n", person)
}

1
2
3
4
5
6
7
8
9
10
11
12
13

• 创建指针类型结构体
  我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：

type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	var p2 = new(Person)
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)
}

1
2
3
4
5
6
7
8
9
10
11
12

可以看到：结构体成员变量没有显示赋值的，均是对应类型的0值
同时这里的p2是一个结构体指针
我们可以使用指针的基本操作来对这个new出来的结构体变量的成员进行赋值操作：

func main() {
	var p2 = new(Person)
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)

	//使用指针的操作方式对Person成员进行赋值
	(*p2).Name = "GGBond"
	p2.Age = 18
	p2.City = "深圳"

	fmt.Printf("p2=%+v\n", p2)
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：
 在Go语言中支持对结构体指针直接使用 .来访问结构体的成员
 不支持像C/C++ 使用 ->的方式访问

• 取结构体的地址实例化
  使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作

type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	var p2 = &Person{}
	
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)

	//使用指针的操作方式对Person成员进行赋值
	(*p2).Name = "GGBond"
	p2.Age = 18
	p2.City = "深圳"

	fmt.Printf("p2=%+v\n", p2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.3、结构体初始化

没有初始化的结构体，其成员变量都是对应其类型的零值
常见的结构体初始化方式有以下几种：

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

type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		City: "深圳",
	}
	fmt.Printf("person = %+v\n", person)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值

• 使用值得列表初始化
  初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：

type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	person := &Person{
		"GGBond",
		18,
		"深圳",
	}
	fmt.Printf("person = %#v\n", person)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用这种格式初始化时，需要注意：
  必须初始化结构体的所有字段
  初始值的填充顺序必须与字段在结构体中的声明顺序一致
  该方式不能和键值初始化方式混用

2.4、结构体内存布局

结构体占用一块连续的内存空间

type test struct {
	a int8
	b int8
	c int8
	d int8
}


func main() {
	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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

再来看另外一个例子：

type Bar struct {
	x int32 // 4
	y *int  // 8
	z bool  // 1
}

func main() {
	var b1 Bar
	fmt.Println(unsafe.Sizeof(b1)) // 24
}
1
2
3
4
5
6
7
8
9
10

疑问1：既然结构体的内存是“连续”的，为什么结构体大小不是13（4 + 8 + 1）而是24呢？

接着再来看另一个场景：

type Bar struct {
	y *int  // 8
	x int32 // 4
	z bool  // 1
}

func main() {
	var b1 Bar
	fmt.Println(unsafe.Sizeof(b1)) // 24
}
1
2
3
4
5
6
7
8
9
10

疑问2：为什么看似“一样”的代码，就是结构体成员变量的定义顺序不一样，得到的结构体大小却不一样了？

好，想要解决这两个问题，那就得说说结构体中最常见的知识：结构体内存对齐

Go 在编译的时候会按照一定的规则自动进行内存对齐。之所以这么设计是为了减少 CPU 访问内存的次数，加大 CPU 访问内存的吞吐量。如果不进行内存对齐的话，很可能就会增加CPU访问内存的次数

针对上面提到的两个问题，我们可以通过内存对齐的角度来分析

type Bar struct {
	x int32 // 4
	y *int  // 8
	z bool  // 1
}
1
2
3
4
5

这个结构体对应的内存示意图如下所示：

对于另一个结构体，他的内存示意图又是另一种情况

type Bar struct {
	y *int  // 8
	x int32 // 4
	z bool  // 1
}
1
2
3
4
5

我们可以看到，结构体成员变量的定义位置不一样，同一对其规则下就会产生不同大小的结构体。具体的对齐规则参考：
结构体详解
内存对齐-李文周

空结构体是不占用内存空间的

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

由于空结构体struct{}的大小为 0，所以当一个结构体中包含空结构体类型的字段时，通常不需要进行内存对齐。例如：

type Demo1 struct {
	m struct{} // 0
	n int8     // 1
}

var d1 Demo1
fmt.Println(unsafe.Sizeof(d1))  // 1
1
2
3
4
5
6
7

但是当空结构体类型作为结构体的最后一个字段时，如果有指向该字段的指针，那么就会返回该结构体之外的地址。为了避免内存泄露会额外进行一次内存对齐

type Demo2 struct {
	n int8     // 1
	m struct{} // 0
}

var d2 Demo2
fmt.Println(unsafe.Sizeof(d2))  // 2
1
2
3
4
5
6
7

2.5、方法和接收者

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

方法的定义格式如下：

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

详细解释：

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

e.g

type Person struct {
	Name string
	Age  int8
}

func newPerson(name string, age int8) *Person {
	return &Person{
		Name: name,
		Age:  age,
	}
}

func (p Person) Freedom() {
	fmt.Printf("%v 向往自由\n", p.Name)
}

func main() {
	ggbond := newPerson("GGBond", 18)
	ggbond.Freedom()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

问：指针类型的 接收者和值类型的接收者有什么区别？应该如何选择？

• 值类型接收者
  当方法作用于值类型的接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获得接收者的成员值，但修改的内容只是针对复制的副本，无法修改接收者变量本身。
• 指针类型接收者
  指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self

什么时候该用指针接收者类型呢？

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

2.6、任意类型添加方法

在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
}
1
2
3
4
5
6
7
8
9
10
11
12
13

注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法

2.7、结构体匿名字段

结构体允许其成员字段在申明的时候没有字段名只有字段类型，这种没有名字的字段就称为匿名字段

type Person struct {
	string
	int
}

func main() {
	person := Person{
		"GGBond",
		18,
	}

	fmt.Printf("%#v\n", person)
	fmt.Printf("person.string is : %v, person.int is : %v\n", person.string, person.int)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：

• 这里的匿名字段说法并不是说没有字段名，而是默认会采用类型名作为字段名
• 结构体要求字段名唯一，因此一个结构体中同种类型的匿名字段只能有一个

2.8、嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。示例如下：

type Address struct {
	Province string
	City     string
}

type Person struct {
	Name    string
	Age     int8
	Address Address
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

当然，也支持 嵌套匿名字段，将上述的Person结构体中的Address字段设置为匿名字段

type Address struct {
	Province string
	City     string
}

type Person struct {
	Name    string
	Age     int8
	Address //匿名字段
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)

	person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
	person.City = "西安"             //匿名字段可以直接省略
	fmt.Printf("%#v\n", person)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找

• 嵌套结构体的字段名冲突
  嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。

type Address struct {
	Province   string
	City       string
	CreateTime string
}

type Email struct {
	Account    string
	CreateTime string
}

type Person struct {
	Name    string
	Age     int8
	Address //匿名字段
	Email
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)

	person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
	person.City = "西安"             //匿名字段可以直接省略
	//person.CreateTime = "xxxx"  //错误写法，会产生歧义
	person.Address.CreateTime = "xxx"
	person.Email.CreateTime = "111"

	fmt.Printf("%#v\n", person)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2.9、结构体的“继承”

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() //乐乐会动！
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2.10、结构体与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 < 5; 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"
			}
		]
	}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

2.11、结构体标签（Tag）

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

结构体tag由一个或多个键值对组成。
键与值使用冒号分隔，值用双引号括起来。
同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

注意事项：
 为结构体编写Tag时，必须严格遵守键值对的规则。
 结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。

例如我们为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:   "GGBond",
	}
	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":"男"}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.12、补充说明

因为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: "GGbond", age: 18}
	data := []string{"吃饭", "睡觉", "打豆豆"}
	p1.SetDreams(data)

	// 你真的想要修改 p1.dreams 吗？
	data[1] = "不睡觉"
	fmt.Println(p1.dreams) // ?
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

针对这种情况，我们需要避免结构体字段与切片共用底层数组
所以，SetDreams的实现方式需要加以修改：

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

这样修改之后就不会存在上面的情况了