Go 结构体：匿名字段与嵌入结构体

Go 语言中的结构体（struct）支持一种特殊语法：匿名字段（anonymous field），也常被称为 嵌入结构体（embedded struct）。这种机制不是传统面向对象语言中的“继承”，而是一种组合方式，能让一个结构体直接“包含”另一个结构体的字段和方法，并在外部像使用自己的成员一样访问它们。掌握这一特性，可以写出更简洁、复用性更高的代码。

理解匿名字段的基本写法

定义结构体时，如果字段只有类型名而没有显式字段名，Go 会自动将该类型的名称（或包路径+类型名）作为字段名。这就是匿名字段。

定义一个包含匿名字段的结构体：

type Person struct {
    Name string
    Age  int
}

type Employee struct {
    Person // 匿名字段：嵌入 Person 结构体
    Salary float64
}

上述代码中，Employee 结构体嵌入了 Person。这意味着：

• Employee 自动拥有 Name 和 Age 字段。
• 可以直接通过 emp.Name 访问，无需写成 emp.Person.Name（尽管后者也合法）。

创建并使用嵌入结构体的实例：

func main() {
    emp := Employee{
        Person: Person{Name: "张三", Age: 30},
        Salary: 15000.0,
    }
    fmt.Println(emp.Name)   // 输出：张三
    fmt.Println(emp.Age)    // 输出：30
    fmt.Println(emp.Salary) // 输出：15000
}

注意初始化时仍需显式指定 Person 字段的值，因为 Go 要求结构体字面量必须明确字段归属（避免歧义）。

匿名字段的本质是“提升”（Promotion）

Go 并不会真正把嵌入结构体的字段“复制”到外层结构体中。它只是在编译期提供了一种“提升”规则：当访问 emp.Name 时，编译器会自动查找是否存在名为 Name 的字段；如果没有，则查找所有匿名字段中是否包含 Name，如果有且唯一，就等价于 emp.Person.Name。

这带来两个关键影响：

1. 字段冲突会导致编译错误。
2. 方法也可以被提升。

字段名冲突示例

type A struct {
    Value int
}

type B struct {
    Value int
}

type C struct {
    A
    B
}

此时，尝试访问 c.Value 会报错：ambiguous selector c.Value。因为 A 和 B 都有 Value，Go 无法确定你要的是哪一个。

解决方法：必须显式指定路径：

c.A.Value = 10
c.B.Value = 20

方法的提升

如果嵌入的结构体有方法，这些方法也会被“提升”到外层结构体。

type Person struct {
    Name string
}

func (p Person) SayHello() {
    fmt.Println("Hello, I'm", p.Name)
}

type Employee struct {
    Person
    ID string
}

func main() {
    e := Employee{
        Person: Person{Name: "李四"},
        ID:     "E001",
    }
    e.SayHello() // 输出：Hello, I'm 李四
}

这里 e.SayHello() 实际上调用的是 e.Person.SayHello()，但语法上可以直接写 e.SayHello()。

嵌入接口：实现多态组合

除了结构体，Go 还允许将接口类型作为匿名字段嵌入。这常用于组合多个行为。

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

type ReadWriter struct {
    Reader
    Writer
}

只要 ReadWriter 的实例被赋予实现了 Reader 和 Writer 的具体类型，就可以直接调用 rw.Read() 和 rw.Write(...)。

注意：嵌入接口不会自动实现该接口。你仍需在构造时传入满足接口的对象。

type MyReader struct{}

func (m MyReader) Read() string { return "data" }

type MyWriter struct{}

func (m MyWriter) Write(data string) { fmt.Println("Wrote:", data) }

func main() {
    rw := ReadWriter{
        Reader: MyReader{},
        Writer: MyWriter{},
    }
    fmt.Println(rw.Read())      // 输出：data
    rw.Write("hello")           // 输出：Wrote: hello
}

嵌套嵌入与字段访问路径

结构体可以多层嵌入。访问字段时，Go 会沿着嵌入链向上查找。

type Animal struct {
    Species string
}

type Mammal struct {
    Animal
    WarmBlooded bool
}

type Dog struct {
    Mammal
    Breed string
}

此时，Dog 实例可以直接访问 Species：

d := Dog{
    Mammal: Mammal{
        Animal: Animal{Species: "Canis lupus"},
        WarmBlooded: true,
    },
    Breed: "Husky",
}
fmt.Println(d.Species) // 输出：Canis lupus

背后的查找路径是：d.Species → 查找 Dog 自身无 → 查找匿名字段 Mammal → Mammal 自身无 → 查找其匿名字段 Animal → 找到 Species。

匿名字段 vs 命名字段：何时使用？

实战：构建可扩展的 HTTP 处理器

利用嵌入结构体，可以优雅地组织 Web 处理逻辑。

type BaseHandler struct {
    DB *sql.DB
}

func (b *BaseHandler) Log(msg string) {
    fmt.Println("[LOG]", msg)
}

type UserHandler struct {
    BaseHandler // 嵌入基础功能
}

func (u *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    u.Log("Handling user request")
    // 使用 u.DB 查询数据库
    w.Write([]byte("User endpoint"))
}

这样，所有业务处理器都可以嵌入 BaseHandler，自动获得日志、数据库连接等基础设施，而无需重复声明字段或写样板代码。

定义结构体时使用匿名字段
访问嵌入字段时直接使用字段名
处理冲突时显式指定嵌入路径
利用方法提升简化调用逻辑