go语言学习-结构体

1、简介

• Go语言中的结构体是一种自定义数据类型，可以将不同类型的数据字符组合在一起形成一个单独的实体。
• 结构体可以用于存储和操作复杂的数据结构，以及创建自定义数据类型。通过自定义结构体创建的变量，可以存储不同类型的数据字段。
• 在实际开发中，结构体的用途非常广泛，常用于表示复杂的实体，例如数据库中的表结构、API按口的数据格式等。使用结构体不仅可以提高代码的模块化程度，还可以实现复杂数据结构的创建、修改和传递。

2、结构体使用

2.1 简单示例

package main

import "fmt"

// 想象一种情况，假如我们需要描述一个“人”的信息，这个人有姓名，性别，年龄，手机号，身份证号，家庭住址等，我们该怎么定义？
// ID，姓名，性别，年龄，手机号，身份证号，家庭住址： int, string, string, int, int, int,string
// 这个时候 如果自定义一个类型，比如这个类型就叫People，然后他有这么多属性 我们直接传递值是不是就可以
// 这个问题就可以用go语言的结构体解决。
// 结构体是由一个或多个不同类型或相同类型的数据组成的数据集合，通过自定义结构体创建的变量，可以存储不同类型的数据字段。
// 结构体在程序开发时，用途非常广泛，不仅可以提高代码的模块化程度，还可以实现复杂数据结构的创建、修改、传递等

// 定义一个结构体
// type 结构体名称 struct
type People struct {
	Name    string //结构体具有的属性 属性名 类型
	Sex     string
	Age     int
	Address string
}

func main() {
	// 创建以后就可以像其他类型一个进行变量的定义
	var p People
	// 之后可以通过p.xxx进行赋值  结构体.成员名
	p.Name = "杜宽"
	p.Sex = "男"
	p.Age = 18
	p.Address = "北京"
	fmt.Printf("定义的数据是: %v, 姓名是:%s\n", p, p.Name)

	//也可以在定义变量时直接赋值
	var p2 People = People{"Dotbalo", "Man", 19, "Russia"}
	fmt.Printf("定义的数据是: %v, 姓名是:%s \n", p2, p2.Name)

	// 使用语法糖进行定义
	p3 := People{"Maria", "Women", 19, "Russia"}
	fmt.Printf("定义的数据是: %v, 姓名是:%s \n", p3, p3.Name)

	// 结构体可以直接赋值
	p = p3
	fmt.Printf("赋值后的数据是: %v, 姓名是:%s\n", p, p.Name)

	// 结构体也可以判断是否相等
	fmt.Println("p2和p3是否相等:", p2 == p3)
}
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

2.2 自定义类型

package main
import "fmt"

// 结构体可以理解为一个自定义的类型，我们可以给自定义的类型创建各种各样的方法（功能），就像原生的类型一样，也是有很多方法的，可以对数据做不同的处理
// 比如定义一个People类型，可以有吃饭、获取详情以及工作挣钱等功能
// 一个经典的案例，定义一个机器人的类型，机器人有很多功能比如开机、关机、升级、走路等等
// 这些功能都叫做方法

// 定义一个结构体
// type 结构体名称 struct
type People struct {
	Name    string //结构体具有的属性 属性名 类型
	Sex     string
	Age     int
	Address string
}
/*
注意：此处的people的*号添加和没有添加是有区别的。参考数据结构中内存地址与指针章节。
	1、p: 表示接收者，是这个函数方法的参数
	2、people: 接收者的类型：值类型和指针类型
		1、值类型：相当于声明了一个新的变量，在方法中修改新变量的值不会影响原有的值。
		2、指针类型：在方法中修改新变量的值会影响原有的值（即main函数中传入方法的值）。
	3、 * 表示指针对应的内存地址的值。 不加 * 表示值类型。

*/
// 定义一个方法，比如打印People类型的变量的详细信息
func (p *People) getInfo() string {
	return fmt.Sprintf("您的信息如下: \n \t姓名: %s\n \t性别: %s\n \t年龄: %d\n \t地址: %s\n", p.Name, p.Sex, p.Age, p.Address)
}

// 定义第二个方法
// go语言使用大小写决定方法、变量等元素是否能被其他包访问
// 大写开头为公有元素，可以被其他包访问，小写开头为私有元素，只能被本包使用
func (p *People) Eat(food string) {
	fmt.Printf("%s吃了: %s", p.Name, food)
}
func main() {
	// 创建以后就可以像其他类型一个进行变量的定义
	var p People
	// 之后可以通过p.xxx进行赋值  结构体.成员名
	p.Name = "张"
	p.Sex = "男"
	p.Age = 18
	p.Address = "北京"
	// 直接调用struct内的方法
	pInfo := p.getInfo()
	fmt.Println(pInfo)
	// 调用另外一个方法
	p.Eat("菠萝")
}
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

2.3 结构体嵌套

package main

import "fmt"

// 当结构体比较复杂时，可以设置为多个结构体，之后可以在某一个结构体的成员变量中设置为另一个结构体类型
// 或者多个结构体有相互依赖关系时，可以使用结构体嵌套

// 比如在定义一个Phone的结构体，用来表示手机的型号，同时人可以拥有手机
type Phone struct {
	Model string
	Price float32
}

type People struct {
	Name    string //结构体具有的属性 属性名 类型
	Sex     string
	Age     int
	Address string
	Mobile  Phone
}

// 定义一个方法，比如打印People类型的变量的详细信息
func (p *People) getInfo() string {
	return fmt.Sprintf("您的信息如下: \n \t姓名: %s\n \t性别: %s\n \t年龄: %d\n \t地址: %s\n", p.Name, p.Sex, p.Age, p.Address)
}

// 定义第二个方法
// go语言使用大小写决定方法、变量等元素是否能被其他包访问
// 大写开头为公有元素，可以被其他包访问，小写开头为私有元素，只能被本包使用
func (p *People) Eat(food string) {
	fmt.Printf("%s吃了: %s\n", p.Name, food)
}

// 定义Phone的方法
func (ph *Phone) call(name string) {
	fmt.Println("打电话给:", name)
}
func main() {
	// 创建以后就可以像其他类型一个进行变量的定义
	var p People
	// 之后可以通过p.xxx进行赋值  结构体.成员名
	p.Name = "张"
	p.Sex = "男"
	p.Age = 18
	p.Address = "北京"
	// 直接调用struct内的方法
	pInfo := p.getInfo()
	fmt.Println(pInfo)
	// 调用另外一个方法
	p.Eat("菠萝")

	// 假设有一个苹果手机
	ph := Phone{"iPhone 18 Pro Max", 9999.99}
	p.Mobile = ph
	fmt.Printf("%s拥有的手机是:%s, 价格是:%f\n", p.Name, p.Mobile.Model, p.Mobile.Price)
	// 打电话给小明
	p.Mobile.call("小明")
}
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