在现实生活中,一个事物通常具有多种不同的属性,需要借助不同的数据类型才能准确描述。比如一名学生的基本信息,一般包含字符串类型的姓名、整数类型的年龄以及浮点数类型的成绩。
对于相同类型的多个数据,我们可以使用数组或切片来保存。但是对于不同类型的多个数据,此时又应该怎么组合在一起呢?这个时候就需要用到 Go 语言中的 “结构体(struct)” 了。
定义结构体
在 Go 语言中,我们可以使用 type 和 struct 这两个关键字来定义一个结构体类型。其中,type 表示定义类型,而 struct 是 “structure(结构体)” 的缩写。
定义结构体类型,就像先印制一张空白的 “学生信息登记表”,规定好表里有哪些栏目。后面创建具体的结构体变量,则是拿这张空白表填写某位同学的真实信息,两者的关系如下图所示。

语法:
type 结构体名 struct {
字段名1 字段类型1
字段名2 字段类型2
...
}说明:
在大括号 {} 内部,每一行定义一个属性,在 Go 语言中称为 “字段(field)”。结构体名和字段名都需要符合标识符命名规范,结构体类型名一般采用首字母大写的驼峰命名(如 Student)。
定义字段时,字段名写在前面,字段类型写在后面,行尾不需要加分号。如果相邻的几个字段属于同一种数据类型,也可以合并写在同一行并用英文逗号隔开,例如 Width, Height float64。
当我们只声明了一个结构体变量、还没有赋具体值时,结构体内部的每一个字段都会自动取各自对应类型的默认零值。
示例 1:结构体的默认零值
package main
import "fmt"
// 定义结构体类型
type Student struct {
Name string
Age int
Score float64
}
func main() {
var stu Student
fmt.Println(stu)
fmt.Printf("%+v\n", stu)
}运行结果如下。
{ 0 0}
{Name: Age:0 Score:0}分析:
在这个例子中,我们使用 type Student struct 定义了 Student 类型,包含 Name、Age、Score 这 3 个字段。小伙伴们要注意区分,Student 只是一个 “类型名”,stu 才是真正存数据的 “结构体变量”。
声明 var stu Student 时没有赋初值,Name 会自动取空字符串 "",Age 和 Score 会自动取 0。由于空字符串在屏幕上看不见,fmt.Println(stu) 打印出的 { 0 0} 左花括号后面才会多出一个空格。
为了让输出结果更直观,第 2 行调用了 fmt.Printf() 并配合 %+v 占位符,把字段名和字段值一起打印出来。其中 Name: 后面为空就代表它是空字符串,平时调试代码时非常实用。
注意: 在同一个包内部,结构体名和字段名的首字母写大写或小写都能正常使用。不过在 Go 语言中,只有首字母大写的名称才能跨包访问,后面学习包管理时会详细介绍。因此在实际开发中,我们通常习惯把公开字段的首字母大写,比如写成 Name 而不是 name。
初始化结构体变量
定义好结构体类型后,我们在创建结构体变量时通常会直接给各个字段赋初始值。初始化结构体一般分为 2 种方式:一种是 “指定字段名初始化”,另一种是 “按顺序初始化”。
语法:
// 方式 1(推荐)
变量名 := 结构体名{字段名1: 值1, 字段名2: 值2}
// 方式 2
变量名 := 结构体名{值1, 值2, 值3}说明:
使用方式 1 时,大括号内采用 字段名: 值 的键值对形式。这种写法不仅可以自由调整字段顺序,还能只给一部分字段赋值,未指定的字段会自动取默认零值。
如果大括号内部什么都不写(如 Student{}),所有字段都会保持默认零值。此外,当把键值对分成多行书写时,每一行的末尾(包括最后一行)都必须加上英文逗号(,)。
示例 2:指定字段名初始化
package main
import "fmt"
type Student struct {
Name string
Age int
Score float64
}
func main() {
// 初始化全部字段
stu1 := Student{
Name: "Jack",
Age: 20,
Score: 95.5,
}
// 只初始化部分字段
stu2 := Student{Name: "Lucy"}
// 空花括号初始化
stu3 := Student{}
fmt.Printf("%+v\n", stu1)
fmt.Printf("%+v\n", stu2)
fmt.Printf("%+v\n", stu3)
}运行结果如下。
{Name:Jack Age:20 Score:95.5}
{Name:Lucy Age:0 Score:0}
{Name: Age:0 Score:0}分析:
在上面代码中,stu1 采用多行键值对的形式给全部 3 个字段赋了初值。这里要特别留意,多行初始化时最后一行 Score: 95.5, 末尾的英文逗号不能省略,漏写会直接触发编译报错。
stu2 只给 Name 字段赋了值,未指定的 Age 和 Score 自动取默认值 0。而 stu3 := Student{} 使用空花括号初始化,效果与 var stu3 Student 相同。
除了指定字段名之外,我们在初始化时也可以省略字段名,直接按照结构体定义时的字段顺序依次填值。请看下面例子。
示例 3:按顺序初始化结构体
package main
import "fmt"
type Student struct {
Name string
Age int
Score float64
}
func main() {
stu := Student{"Tony", 18, 88.5}
fmt.Printf("%+v\n", stu)
}运行结果如下。
{Name:Tony Age:18 Score:88.5}分析:
Student{"Tony", 18, 88.5} 省略了字段名,此时编译器会严格按照 Student 定义时的字段顺序,将 3 个值依次赋给 Name、Age 和 Score。
需要注意的是,省略字段名初始化时,我们必须把每一个字段都按顺序填满,既不能少填也不能调换顺序。如果漏填了任意一个字段,编译时就会报错:
stu := Student{"Tony", 18} // 漏填第 3 个字段会报错上面这行代码只提供了两个值,漏掉了第 3 个字段 Score。编译时会直接报错 too few values in struct literal,提示结构体字面量中的值太少。
在实际开发中,我们更推荐使用带字段名的 Student{Name: "Jack", Age: 20} 方式来初始化结构体。这样不仅代码一目了然、不用死记字段顺序,而且以后往结构体中新增字段时,原有的初始化代码也不会报错。
访问与修改结构体字段
创建好结构体变量之后,如果我们想要读取或者修改结构体内部某一个字段的值,统一使用英文点号(.)来连接结构体变量名和字段名。
语法:
结构体变量名.字段名
结构体变量名.字段名 = 新值说明:
把 结构体变量名.字段名 放在等号右边或直接打印,表示读取该字段的值。把它放在等号左边(如 stu.Age = 21),则表示修改该字段的值。
示例 4:读取与修改结构体字段
package main
import "fmt"
type Student struct {
Name string
Age int
}
func main() {
stu := Student{Name: "Jack", Age: 20}
// 读取字段的值
fmt.Println(stu.Name)
fmt.Println(stu.Age)
// 修改字段的值
stu.Age = 21
fmt.Println(stu.Age)
}运行结果如下。
Jack
20
21分析:
stu.Name 和 stu.Age 分别表示获取结构体变量 stu 中的姓名和年龄。随后执行的 stu.Age = 21 将年龄字段修改成了 21,再次打印 stu.Age 时输出的就是更新后的值 21。
结构体的值类型特性
在 Go 语言中,结构体和定长数组一样,都属于 “值类型”。当我们把一个结构体变量赋值给另一个变量或传给函数时,程序会把所有字段完整复制一份,生成一个独立的副本。
示例 5:结构体赋值产生独立副本
package main
import "fmt"
type Student struct {
Name string
Age int
}
func main() {
stu1 := Student{Name: "Jack", Age: 20}
stu2 := stu1
// 修改副本 stu2 的字段
stu2.Name = "Lucy"
fmt.Println(stu1.Name)
fmt.Println(stu2.Name)
}运行结果如下。
Jack
Lucy分析:
stu2 := stu1 表示把 stu1 的数据完整复制一份交给 stu2,两者在内存中完全独立。因此,修改 stu2.Name = "Lucy" 后,原本的 stu1.Name 依然保持为 "Jack"。
如果希望在传递时不产生副本,或者需要在函数内部直接修改原结构体的数据,我们可以配合下一节要学习的结构体指针来实现。
结构体的比较
如果两个结构体变量属于同一种结构体类型,并且内部所有字段都支持判等比较,我们就可以直接使用 == 或 != 运算符判断它们是否相等。
只有当两个结构体中每一个对应字段的值都完全相等时,== 才会返回 true。只要有任意一个字段的值不同,就会返回 false。
示例 6:使用 == 比较两个结构体
package main
import "fmt"
type Student struct {
Name string
Age int
}
func main() {
stu1 := Student{Name: "Jack", Age: 20}
stu2 := Student{Name: "Jack", Age: 20}
stu3 := Student{Name: "Jack", Age: 22}
fmt.Println(stu1 == stu2)
fmt.Println(stu1 == stu3)
}运行结果如下。
true
false分析:
从运行结果可以看出,stu1 和 stu2 的各个字段一一相等,因此 stu1 == stu2 返回 true。而 stu3 的年龄是 22,与 stu1 不同,所以 stu1 == stu3 返回 false。
在使用 == 比较结构体时,小伙伴们还要注意以下 2 个限制条件:① 不同类型的结构体变量之间不能直接比较;② 结构体内部的所有字段本身也必须支持 == 比较。
由于切片和 Map 本身不支持 == 判等,一旦结构体内部包含了切片或 Map 字段,该结构体就不能直接使用 == 比较了。如果像下面这样直接比较,编译时就会报错:
type Class struct {
Name string
Users []string // 切片字段不支持 == 比较
}
c1 := Class{Name: "一班"}
c2 := Class{Name: "一班"}
fmt.Println(c1 == c2) // 编译报错编译上面这段代码时,编译器会提示 struct containing []string cannot be compared,表示包含字符串切片的结构体无法直接比较。这一点小伙伴们平时定义结构体时要留意。
匿名结构体(了解)
有时候,我们只是想临时把两三个不同类型的数据打包在一起,而且在当前函数里只用这一次,不打算专门在外面使用 type 定义新类型名。这时就可以直接使用 “匿名结构体”,在声明变量的同时定义结构并赋初值。
示例 7:使用匿名结构体
package main
import "fmt"
func main() {
// 定义并初始化匿名结构体
config := struct {
Host string
Port int
}{
Host: "127.0.0.1",
Port: 8080,
}
fmt.Printf("%+v\n", config)
}运行结果如下。
{Host:127.0.0.1 Port:8080}分析:
匿名结构体省去了 type 结构体名,直接把 struct { ... } 当作类型名,后面紧跟 { ... } 初始化数据即可。读写里面的字段同样直接使用点号(如 config.Host)。这种写法在后面学习临时解析 JSON 数据和编写单元测试时会经常遇到,这里小伙伴们先混个眼熟即可。
Go 结构体与其他语言的类
学过 C++、Java 或 Python 的小伙伴可能会好奇:为什么 Go 语言里没有专门的 class(类)关键字呢?实际上,传统面向对象语言习惯把数据属性、构造函数以及父子继承关系全部捆绑在 class 里面。
而 Go 语言提倡更加简洁的 “组合” 思想,直接去掉了 class 关键字,只保留纯粹的 struct 结构体来存放数据属性。平时我们只需要配合后面要学习的方法和结构体嵌套,就能轻量灵活地实现面向对象开发。
