Go 结构体嵌套

在实际开发中,一个复杂的数据结构通常是由几个小结构组合而成的。比如一个 “用户(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 就会在运行时触发空指针崩溃。
给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号