
 
 

如果你写过 Go，你一定见过这种“套娃”式的初始化：

```go
type User struct {
    Name string
    Age  int
}

type Product struct {
    Title  string
    Price  float64
    InStock bool
}

type Order struct {
    OrderID string
    User    // 匿名嵌入
    Product // 匿名嵌入
}
```

以前你想创建一个 `Order` 对象，得这样写：

```go
o := Order{
    OrderID: "ORD-123",
    User: User{
        Name: "张三",
        Age:  28,
    },
    Product: Product{
        Title:  "机械键盘",
        Price:  399.00,
        InStock: true,
    },
}
```

明明我只是想设置 `Name` 和 `Price`，却得先写 `User`、`Product`，再写里面的字段。这种嵌套让我想起了过年拆礼物——要剥开好几层包装纸才能拿到想要的东西。

**好消息是：Go 1.27 终于把包装纸撕了。**

---

## 新写法：直接喊名字，不用绕路

在 Go 1.27 里，你可以这样写：

```go
o := Order{
    OrderID: "ORD-456",
    Name:    "李四",        // 直接从 User 提上来的
    Age:     32,            // 直接从 User 提上来的
    Title:   "电竞显示器",   // 直接从 Product 提上来的
    Price:   1999.00,       // 直接从 Product 提上来的
    InStock: true,          // 直接从 Product 提上来的
}
```

9 行变 7 行，少打了 2 行，少看了 2 层嵌套，眼睛舒服了，手指也舒服了。

---

## 为什么这事值得高兴？

Go 的嵌入式（embedding）一直是个很“分裂”的特性：

- **访问字段的时候**：`o.Name`（直接），秒到
- **初始化的时候**：`User: User{Name: ...}`（绕路），像在迷宫

现在终于一致了——**访问和初始化用的是同一套名字**。不用再记“这个字段来自哪个嵌入类型”，直接写就行了。

---

## 更深层的情况：两层嵌入

如果嵌入再深一层呢？

```go
type CPU struct {
    Model    string
    Cores    int
    Frequency float64
}

type Laptop struct {
    CPU // 匿名嵌入
    RAM int
    SSD int
}

type Inventory struct {
    SKU     string
    Laptop  // 匿名嵌入（两层深度）
}
```

在 Go 1.26 里，你得这样写：

```go
inv := Inventory{
    SKU: "MBP-2026",
    Laptop: Laptop{
        CPU: CPU{
            Model:    "M5 Ultra",
            Cores:    12,
            Frequency: 3.8,
        },
        RAM: 32,
        SSD: 1024,
    },
}
```

在 Go 1.27 里：

```go
inv := Inventory{
    SKU:       "MBP-2026",
    Model:     "M5 Ultra",   // 从 CPU 穿过 Laptop 提上来的
    Cores:     12,           // 同上
    Frequency: 3.8,          // 同上
    RAM:       32,           // 从 Laptop 直接提上来的
    SSD:       1024,         // 从 Laptop 直接提上来的
}
```

10 行变 7 行，少了 30%。**嵌套越深，收益越明显。**

---

## 什么时候该用旧写法？

新特性不是万能的。有两种情况你还是要用老写法：

**1. 字段名冲突**

如果两个嵌入类型有同名字段，编译器会报错：

```go
type ConfigA struct { Timeout int }
type ConfigB struct { Timeout int }
type App struct { ConfigA; ConfigB }

// 编译错误：ambiguous field Timeout
// app := App{ Timeout: 30 }
```

必须用嵌套语法来消除歧义：

```go
app := App{
    ConfigA: ConfigA{Timeout: 30},
    ConfigB: ConfigB{Timeout: 60},
}
```

**2. 想让代码意图更清晰**

如果嵌入类型有 20 个字段，你只用了其中 3 个，旧写法能让人一眼看出“这些字段来自哪里”：

```go
// 用旧写法，一眼看出这三个字段属于数据库配置
config := AppConfig{
    Database: DatabaseConfig{
        Host: "localhost",
        Port: 5432,
        Name: "mydb",
    },
}

// 用新写法，字段来源不明确
config := AppConfig{
    Host: "localhost",  // 这是数据库配置？缓存配置？还是顶层字段？
    Port: 5432,
    Name: "mydb",
}
```

**原则：默认用新写法，需要消除歧义或提升可读性时用旧写法。**

---

## 总结

Go 1.27 的“键名字段”是一个很小的语法改动，但影响面很广。它没有引入新概念，只是把 Go 一直存在的“字段提升”机制，延伸到了结构体字面量的初始化中。

这种改动不会上头条，但会在你每次写代码的时候悄悄省下几秒钟——一年下来，可能就是几个小时。

如果你经常用嵌入式 struct（在 Go 里这几乎是标配），你会在第一次用的时候就感受到差别。

就像有人帮你把“俄罗斯套娃”拆开，你终于可以直接拿到最里面那个娃娃了。

明明我只是想设置 Name 和 Price，却得先写 User、Product，再写里面的字段。这种嵌套让我想起了过年拆礼物——要剥开好几层包装纸才能拿到想要的东西。

Go 1.27 新特性：嵌入式字段终于可以不用俄罗斯套娃了

编程语言

Go1.27引入结构体键名字段提升，简化嵌入式struct初始化。可直接用`Order{Name:"李四",Price:1999}`替代嵌套写法，减少30%代码量。字段冲突或需明确来源时仍用旧语法。新特性统一访问与初始化方式，提升代码可读性与开发效率，尤其适合多层嵌入场景。

代码解释

数据库

编译器

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Go 1.27 新特性：嵌入式字段终于可以不用俄罗斯套娃了-腾讯云开发者社区-腾讯云

Go 1.27 新特性：嵌入式字段终于可以不用俄罗斯套娃了

Go 1.27 新特性：嵌入式字段终于可以不用俄罗斯套娃了

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐