在实际开发中,一个复杂的数据结构通常是由几个小结构组合而成的。比如一个 “用户(User)” 除了有姓名和年龄之外,里面一般还会包含一个 “收货地址(Address)”。
在 Go 语言中,将一个结构体作为另一个结构体的字段组合起来,就叫做 “结构体嵌套”。根据内层结构体有没有单独起字段名,结构体嵌套主要有 2 种写法:① 具名嵌套;② 匿名嵌套。
具名嵌套结构体
具名嵌套,从名字上就很好理解,就是在外部结构体中定义一个带有明确字段名的内部结构体字段。当我们需要读写内部结构体的字段时,使用英文点号(.)一层一层往里查找即可。
语法:
type 外层结构体 struct {
字段名 内层结构体类型
}说明:
在具名嵌套中,内层结构体拥有一个独立的字段名。因此读取或修改内层结构体的字段时,我们需要按层级逐层访问(例如 u.Addr.City)。
示例 1:使用具名嵌套结构体
package main
import "fmt"
// 定义地址结构体
type Address struct {
City string
Street string
}
// 具名嵌套 Address
type User struct {
Name string
Addr Address
}
func main() {
u := User{
Name: "Jack",
Addr: Address{
City: "广州",
Street: "天河路",
},
}
fmt.Println(u.Name)
fmt.Println(u.Addr.City)
// 修改内层结构体的字段
u.Addr.City = "深圳"
fmt.Println(u.Addr.City, u.Addr.Street)
}运行结果如下。
Jack
广州
深圳 天河路分析:
在这个例子中,User 结构体里定义了名为 Addr 的地址字段。由于该字段有明确的名字,无论是读取还是修改里面的城市和街道,我们都需要先通过 u.Addr 拿到内层结构体,再点出 u.Addr.City 和 u.Addr.Street。
此外,在多行初始化嵌套结构体时,内层右花括号 }, 末尾的英文逗号同样不能省略,漏写会直接导致编译报错。
匿名嵌套结构体
除了给内层结构体起一个字段名之外,我们在定义结构体时也可以只写内层结构体的类型名,不写字段名。这种写法在 Go 语言中叫做 “匿名嵌套”,也常称为 “内嵌结构体(embedding)”,其中 “embedding” 是 “嵌入” 的意思。
语法:
type 外层结构体 struct {
内层结构体类型
}说明:
当嵌套的结构体不写字段名、只写类型名时,它默认会使用该类型名本身作为字段名。同时,内层结构体的字段和方法都会自动 “提升” 到外层结构体上,我们可以跳过中间层直接使用点号访问,具名嵌套与匿名嵌套的访问差异如下图所示。

示例 2:匿名嵌套的字段提升
package main
import "fmt"
type Address struct {
City string
Street string
}
// 匿名嵌套 Address
type User struct {
Name string
Address
}
func main() {
u := User{
Name: "Jack",
Address: Address{
City: "上海",
Street: "南京路",
},
}
// 直接访问提升后的字段
fmt.Println(u.City)
// 通过完整层级访问
fmt.Println(u.Address.City)
}运行结果如下。
上海
上海分析:
在 User 结构体中,我们只写了类型名 Address 而省略了字段名,编译器会自动把类型名当作这个匿名字段的名字。因此初始化 u 时需要写成 Address: Address{...},冒号左边代表匿名字段名,右边则是内层结构体字面量。
创建好变量 u 之后,Address 内部的 City 字段就会被提升到 User 上,直接写 u.City 和写完整路径 u.Address.City 的效果完全一样。
这里小伙伴们要特别注意,u.City 这种直接访问内层字段的简写,只能在结构体变量创建完成之后使用。使用大括号 {} 初始化字面量时,依然必须按层级写出内层结构体。如果直接在外层大括号里填写内层字段 City,编译时就会报错:
u := User{
Name: "Jack",
City: "上海", // 初始化字面量不能跨层直填
}编译上面这段代码时,会直接报错 unknown field City in struct literal of type User,提示在 User 字面量中找不到 City 字段。
除了字段会自动提升之外,绑定在内层结构体上的方法同样也会自动提升到外层结构体上。通过这种组合方式,Go 语言不需要复杂的父子继承语法,就能轻松复用属性和方法。
示例 3:匿名嵌套的方法提升
package main
import "fmt"
type Animal struct {
Name string
}
// 为 Animal 绑定 Eat 方法
func (a Animal) Eat() {
fmt.Println(a.Name, "正在吃东西")
}
// Dog 匿名嵌套 Animal
type Dog struct {
Animal
Breed string
}
func main() {
d := Dog{
Animal: Animal{Name: "旺财"},
Breed: "柴犬",
}
fmt.Println(d.Name, d.Breed)
// 直接调用提升后的 Eat 方法
d.Eat()
}运行结果如下。
旺财 柴犬
旺财 正在吃东西分析:
Dog 结构体匿名嵌套了 Animal 结构体。这样一来,Dog 不仅直接拥有了 Animal 的 Name 字段,而且连 Animal 绑定的 Eat() 方法也一并复用了过来,在 main() 中可以直接调用 d.Eat()。
提示: 在实际开发中,如果两个结构体是明显的 “包含关系”(比如订单包含收货地址),我们使用具名嵌套语义更清晰。如果是想让外层结构体直接复用公共的属性和方法(比如 Dog 复用 Animal),则更适合使用匿名嵌套。
同名字段与方法的访问规则
在使用匿名嵌套时,如果外层结构体和内层结构体恰好定义了同名的字段或方法,直接通过外层变量访问时会以哪一个为准呢?
其实规则非常简单,Go 语言遵循 “外层优先” 的就近原则。也就是说,程序默认会优先访问外层结构体自己的字段或方法。如果我们确实想访问内层的同名成员,写出完整层级就可以了。
示例 4:外层与内层存在同名字段
package main
import "fmt"
// 定义部门结构体
type Dept struct {
Name string
}
// 员工结构体匿名嵌套 Dept
type Staff struct {
Name string
Dept
}
func main() {
s := Staff{
Name: "Jack",
Dept: Dept{Name: "研发部"},
}
// 默认访问外层 Name
fmt.Println(s.Name)
// 显式访问内层 Name
fmt.Println(s.Dept.Name)
}运行结果如下。
Jack
研发部分析:
外层员工结构体 Staff 和内层部门结构体 Dept 都包含 Name 字段。直接读取 s.Name 时,按照就近原则会优先拿到外层员工的姓名 "Jack"。通过 s.Dept.Name 指定内层类型名后,就能准确拿到内层部门的名称 "研发部"。
同样的就近原则也适用于方法。如果外层结构体定义了与内层同名的方法,调用时就会优先执行外层的新方法,请看下面例子。
示例 5:外层定义同名方法
package main
import "fmt"
type Animal struct {
Name string
}
func (a Animal) Speak() {
fmt.Println(a.Name, "发出叫声")
}
type Dog struct {
Animal
}
// 外层定义同名方法
func (d Dog) Speak() {
fmt.Println(d.Name, "汪汪汪")
}
func main() {
d := Dog{Animal: Animal{Name: "旺财"}}
// 默认调用外层 Speak
d.Speak()
// 显式调用内层 Speak
d.Animal.Speak()
}运行结果如下。
旺财 汪汪汪
旺财 发出叫声分析:
由于外层 Dog 自己也定义了 Speak() 方法,直接调用 d.Speak() 时就会优先执行 Dog 的方法,输出 "旺财 汪汪汪"。这相当于把内层原有的同名方法 “遮挡” 住了。如果小伙伴们仍想调用内层 Animal 原本的方法,显式写成 d.Animal.Speak() 即可。
注意:
- 同级嵌套避免字段歧义:如果外层结构体自身没有定义
Name字段,却同时匿名嵌套了两个都含有Name字段的同级结构体,直接写s.Name会触发ambiguous selector(选择器歧义)编译报错。遇到这种情况,小伙伴们必须写出完整层级来区分。 - 匿名嵌套指针记得初始化:匿名嵌套也支持直接嵌入结构体指针(如
*Address)。如果创建外层结构体时忘记给内层指针赋初值,直接访问提升字段u.City就会在运行时触发空指针崩溃。
