map、结构体与指针Copy Anchor Link

这一章回答一个问题:切片不够用之后,数据往哪放、怎么组织。 三个答案各占一段:map(用任意可比较的键查值,底层是哈希表)、 结构体(把相关字段捆成一个自定义类型,Go 面向对象的全部真相都在这里)、 指针(直接操纵内存地址,函数的参数从此分「拷一份」和「指过去」两种世界)。 读完你会看懂这本书此后每一行数据建模代码。

1. 这一章在原书里的位置Copy Anchor Link

原书第 2 章(Data Collections and Functions)是「Go 快速入门」的第二块。 第 1 章给了原子类型和切片,这一章把「复合数据」补完——然后全书就再也不回头讲基础了。 判断这章的读法:map 一节快读(你会的都覆盖),结构体一节慢读(这是全章重心, 原书在这里一口气演了一个程序的 14 个面貌),指针一节中速(链表例子值得跟着走一遍)。

2. 顶层全景Copy Anchor Link

  map    → 键值对 + 哈希表:O(1) 查找,顺序随机,是引用类型(§3)
  struct → 14 个面貌:定义/嵌入/方法/私有字段/接口/tag/匿名/空结构体(§4–§8)
  指针   → & 和 *,传引用改原件,结构体+指针=链表(§9–§10)

图说:三种机制一个共同主题——谁和谁共享同一份数据。map 和切片共享,结构体默认拷备, 指针显式共享。整章其实就是这一句话的三种展开。

3. map:哈希表是内置类型Copy Anchor Link

map 解决的问题: 切片只能用从 0 开始的连续整数当下标。哪怕你只想用下标 99, 切片也得把 0–98 全占着¹。map 把下标推广成键:字符串、整数、布尔都可以, 条件是「这个类型能用 == 和 != 比较」——不能比较的类型(比如切片)不能当键²。 底层实现是哈希表,插入、删除、查找的平均复杂度都是 O(1)(常数时间)³。

一条主线走完全部规则:学生成绩表Copy Anchor Link

书上用一个 grades map[string]int(学生名字 → 分数)把 map 的全部日常操作串起来, 我们照原书顺序走,每一步是机制,旁边是具体值:

第 1 步,创建。 三种写法,三种脾气:

var grades map[string]int                  // (a) 声明不初始化 → nil map,还不能用
scores := make(map[string]int)             // (b) make 造空 map,能用
inventory := map[string]int{               // (c) 字面量,带初始值
    "apples": 50, "bananas": 30, "oranges": 25,
}
grades = make(map[string]int)              // nil map 必须先 make 才能往里放东西

nil map 是个坑:对 nil map 读是安全的(返回零值),但往里写直接 panic。 所以「声明了没初始化」和「空 map」是两回事⁴。

第 2 步,增和改。 grades["Marietta"] = 95、grades["Athina"] = 92; 键已存在再赋就是改:grades["Marietta"] = 98⁵。输出确认: Grades after adding: map[Athina:92 Epifanios:87 Marietta:95],更新后 Marietta 变 98。

第 3 步,读不存在的键——本章最重要的机制。 grades["David"] 在 David 不存在时不报错,返回 int 的零值 0⁶。 输出里一行 David's grade (doesn't exist): 0。这带来一个真问题: 「键不存在」和「键存在但值就是 0」分不出来。解法是 comma ok 惯用法:

if grade, exists := grades["David"]; exists {
    fmt.Printf("David exists with grade: %d\n", grade)
} else {
    fmt.Printf("David doesn't exist in grades map\n")
}

grades["David"] 其实返回两个值:值本身,和一个「在不在」的布尔。 一次取值两个结果都拿到,这就是这一行在 if 里的写法的全部内容⁷。 输出:David doesn't exist in grades map——而 Marietta 走同一个判断进 true 分支。

第 4 步,删。 delete(grades, "Epifanios");删不存在的键安全,什么都不会发生⁸。

第 5 步,遍历——顺序是随机的。 for name, grade := range grades 同时拿键值; 只拿键、只拿值也都有写法。但 map 的遍历顺序是随机化的,两次运行打印顺序可能不同, 想要确定输出就得把键捞出来排序再按序取值⁹。

第 6 步,map 是引用类型。 copy := original 之后两边是同一张表: 往 copy 里加 "c": 3,original 也变成 map[a:1 b:2 c:3]¹⁰。 这和切片一样、和数组/结构体相反——第二章开头的「谁和谁共享」在这里又出现一次。

第 7 步,两个常用技巧。 一是「map 当集合」:Go 没有集合类型, map[string]struct{}(值为空结构体,零字节)去重,键自动唯一¹¹; 二是「key 排序后遍历」换确定性输出,书上用商品名排序示范¹²。 嵌套 map(map[string]map[string]int,学生→科目→分数)做层级数据,一笔带过¹³。

4. 结构体(一):定义、初始化、嵌入——Go 的「组合式继承」Copy Anchor Link

结构体(struct)把不同类型的字段捆成一个类型:一个 Person 有 Name(string)、 Age(int)、City(string)¹⁴。Go 没有类,结构体就是全部—— 原书用一个大程序从 14 个角度演示,我们合并成四个值得慢读的面貌。

面貌一:嵌入——没有「继承」关键字,字段被「提升」上来Copy Anchor Link

type Person struct { Name string; Age int; City string }
type Address struct { Street, City, State, ZipCode string }

type Employee struct {
    Person                    // 匿名字段:只写类型名,不写字段名
    Address                   // 第二个匿名字段
    ID int; Department string; Salary float64; IsManager bool
}

Employee 里直接写 Person 和 Address 类型名,这叫嵌入(embedding)。 效果是字段提升:emp.Name 直接读到 Person 里的 Name,emp.Street 直接读到 Address 里的 Street,不用写 emp.Person.Name¹⁵。

但这里埋着本章最值钱的一个细节:Person 和 Address 都有 City 字段。 提升规则遇上同名会撞车——emp.City 变得有歧义,编译器直接报错, 必须显式写 emp.Person.City 或 emp.Address.City 二选一¹⁶。

  Employee
   ├── Person  {Name, Age, City} ─┐
   ├── Address {Street, City, …} ─┤ City 撞名 → emp.City 编译报错,必须写全路径
   └── 自己的  {ID, Department, Salary, IsManager}

  图说:嵌入 = 字段提升;提升撞名时,显式路径是唯一的解法。

这就是 Go 对「继承」的回答。 别的语言给子类一条 is-a 链, Go 给的是「把零件嵌进来,字段自动提到外层;撞名了就写全路径」—— 组合(composition)优先于继承,且没有任何隐式的优先级仲裁。

面貌二:初始化与值的脾气Copy Anchor Link

Person 有四种造法:var p1 Person(零值:Name 空串、Age 0、City 空串)、 p2 := Person{}(同上,意图更显式)、 p3 := Person{"Alice", 30, "New York"}(位置初始化:按声明顺序,一个不能少)、 p4 := Person{Name: "Bob", Age: 25, City: "Boston"}(命名字段:顺序随意,可只给一部分)¹⁷。 %+v 打印会连字段名带值一起列出——调试结构体的日常姿势。

结构体是值类型:point4 := point1 拷一份,改 point4.X 不影响 point1; 全字段可比较的结构体可以直接 == 逐字段比¹⁸。 注意书里一句关键小字:「only primitive data types are copied」—— 如果字段里有切片或指针,拷贝的是那个引用,两边仍共享同一份底层数据¹⁹。 「结构体拷贝 = 深拷贝」是错觉,这句话是对 02 号切片那章的呼应。

面貌三:方法、接收者与「没有构造器」的构造器Copy Anchor Link

方法就是一个函数,只是签名前面多了一个接收者(receiver):

func (r Rectangle) Area() float64 { return r.Width * r.Height }  // 值接收者:拿到的是拷贝
func (r *Rectangle) Scale(f float64) { r.Width *= factor; r.Height *= factor }  // 指针接收者:拿到的是地址,改原件

rect.Scale(2) 前后对比是教科书式的:前 {Width:10 Height:5},后 {Width:20 Height:10}; 而值接收者的 Area() 算归算,rect 纹丝不动²⁰。判据一句话:只读用值接收者,要改用指针接收者。 Go 还替你自动补全:rect1.Scale(1.5) 会被编译器悄悄改写成 (&rect1).Scale(1.5), 值和指针两种调用方式对两种接收者都能用(前提:值得有固定地址,临时字面量不行)²¹。

Go 没有构造器关键字,惯例是自己写一个 New 开头的函数(constructor pattern):

type BankAccount struct {
    AccountNumber string    // 大写 → 导出,包外可见
    balance       float64   // 小写 → 未导出,只有本包能碰
    ownerName     string    // 小写 → 同上
}

func NewBankAccount(accountNumber, ownerName string, initialBalance float64) *BankAccount {
    return &BankAccount{AccountNumber: accountNumber, balance: initialBalance, ownerName: ownerName}
}

配上 Deposit/Withdraw 方法(里面校验正数、校验余额),一套封装就齐了: balance 谁也碰不到,只能从方法进出;Withdraw(2000) 超支时报 Invalid withdrawal: insufficient funds,状态不变²²。 Go 的「面向对象」三件套到此全部亮相:结构体当数据、方法挂行为、小写 + New 函数做封装。

面貌四:隐式接口、struct tag、匿名与空结构体Copy Anchor Link

隐式接口是 Go 最大的差异化设计,值得单独看清楚:

type Shape interface {        // 接口 = 一份方法清单
    Area() float64
    Perimeter() float64
}

func (c Circle) Area() float64     { return 3.14159 * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * 3.14159 * c.Radius }
// Circle 从头到尾没说过自己实现了 Shape——不需要说

只要一个类型的方法集合凑齐了清单,它就自动满足接口,不需要 implements 声明。 直接后果:shapes := []Shape{Rectangle{...}, Circle{...}} 把两种具体类型装进同一个切片, shape.Area() 在 Rectangle 上算矩形、在 Circle 上算圆——多态,但没有任何继承语法²³。 (%T 打印出 main.Rectangle/main.Circle,说明接口变量心里始终知道自己装的是谁。)

struct tag:字段后面反引号里的一串元数据,别的库来读:

type User struct {
    ID       int    `json:"id" db:"user_id" validate:"required"`
    Password string `json:"-" db:"password_hash"`             // json:"-" = 序列化时整个字段消失
    FullName string `json:"full_name,omitempty" db:"name"`   // omitempty = 零值时不进 JSON
}

json.Marshal(user) 的输出里,Password 消失了(这就是为什么 API 响应里永远不该有密码), FullName 变成 snake_case 的 full_name,空值时连字段都不出现²⁴。 反射(reflect 包,第 4 章细讲)能在运行期把这些 tag 逐个读出来²⁵。

匿名结构体:类型定义直接写在字段位置上,不另起名。 Config 里的 Database 和 Server 都是匿名结构体——两个「Port」字段不冲突, 因为各自有自己的命名空间 config.Database.Port / config.Server.Port²⁶。 空结构体 struct{}:零字节。unsafe.Sizeof(struct{}{}) 报 0。 所以「map 当集合」用 map[string]struct{}:值的位置不花一分钱内存, 纯靠键的存在性表示「在集合里」²⁷。

5. 结构体(二):作者演示的顺序里藏着的话Copy Anchor Link

值得点破:原书把 BankAccount(封装)排在接口之前、tag 排在匿名结构体之前,这个顺序不是随机的。 它实际讲的是 Go 类型系统的能力梯度:值语义 → 方法 → 访问控制 → 抽象(接口)→ 元数据(tag)→ 一次性结构(匿名)→ 零成本标记(空结构体)。能力一种比一种「省」,代价一种比一种「特定场合才值」。 后四种(接口、tag、匿名、空结构体)各自的代价是:接口丢静态类型信息、tag 把契约挪出了类型系统、 匿名结构体不可复用、空结构体不能带数据。

判断(我们的,不是书里的): 这一章(尤其结构体一节)是全书语言部分信息密度最高的地方, 而且它不是「14 个知识点」,是一条能力梯度。复述这一章的正确方式是说清梯度, 而不是背 14 个名字——这也应该是读任何语言特性清单的姿势。 如果错,会错在: 作者也许只是按教学惯例从简单排到复杂;「能力梯度」是我们后加的组织方式, 原书没有明说,尽管排序事实支持它。

6. 指针:&、* 与传引用Copy Anchor Link

指针两个运算符:&x 取 x 的内存地址,*p 取地址里存的值(解引用)。 书上第一个例子一句话讲完机制:

func updateValue(ptr *int) { *ptr = *ptr + 5 }
// main 里:x := 10;updateValue(&x)
// 输出:Before: 10 → After: 15

&x 把 x 的地址递进去,函数里 *ptr = *ptr + 5:右边读出 10、加 5, 左边把 15 写回同一个内存位置——main 里的 x 就这么被改了²⁸。 没有指针,函数拿到的参数永远是一份拷贝,改拷贝动不了原件。

这一节还预告了 new 和 make 的分工(new 返回指针、make 只用于切片/map/channel), 但详细的对比表原书放在第 4 章(见 05 号拆解的「make 和 new」一节)。

7. 主线例子(二):一条链表,把指针和结构体缝起来Copy Anchor Link

指针的经典用例是自引用数据结构。书上实现了单链表,两个类型:

type Node struct { Value int; Next *Node }   // Next 指向同类型的下一个节点,nil 表示到头
type LinkedList struct { Head *Node }        // Head 为 nil 表示空表

Next *Node 是结构体里装着自己的指针——值类型做不到这个,会陷入无限嵌套, 指针让「节点指向下一个节点」成为可能。四个方法跟着走一遍(插入 5、3、8、1)²⁹:

Insert(追加到尾): 空表(Head == nil)新节点直接当 Head; 否则从头走到 current.Next == nil 的最后一个节点,把它的 Next 指向新节点。 输出 5 -> 3 -> 8 -> 1 -> nil。

Delete(3): 先特判——要删的恰是 Head(把 Head 挪到下一个);否则两个指针并排走: prev 落后 curr 一步,找到 curr.Value == 3 时执行 prev.Next = curr.Next—— 被删节点并没有被释放操作,只是从链上摘了出去(垃圾回收稍后会发现没人再指向它, 这正是第 4 章 GC 的活)。输出 5 -> 8 -> 1 -> nil。

Sort(冒泡): 不搬节点,只交换相邻节点的 Value 字段; swapped 标志控制「整趟没换过就停」。输出 1 -> 5 -> 8 -> nil。

Print: 从头走到 nil,每个值后面打 -> ,结尾打 nil。

  插入:  5 → 3 → 8 → 1 → nil
  删 3:  5 → 8 → 1 → nil        (prev.Next 跳过 curr,curr 悬空待回收)
  排序:  1 → 5 → 8 → nil        (只换值,不挪节点)

  图说:三个操作各动一次链接,指针的指向变化就是算法的全部状态。

图说:链表的全部难度不在逻辑,在「谁先指向谁」的顺序——Delete 里先挪 prev 还是先挪 curr, 写反一行就是断链。这也是指针作为「必须显式管理的关系」的最好教材。

8. 作者的判断与证据Copy Anchor Link

9. 边界与局限Copy Anchor Link

• map 一节没讲并发。 map 不是并发安全的,两个 goroutine 同时写会 panic, 本章只字未提——第 3 章讲并发时才补(sync.Map 也没进那章)。
• 链表是纯教学示例。 生产代码里切片几乎总是更好的选择(缓存友好、少一次间接寻址); 书上没给「什么时候真需要链表」的判断标准。
• 结构体对齐与内存布局(struct padding)没讲。 unsafe.Sizeof 露了一面就收了, 而系统编程里结构体内存布局常是性能关键。
• 接口的「意外实现」风险没提。 隐式实现意味着任何类型凑巧有同名同签名方法 就满足了接口——方便与脆弱同根,原书只讲了方便那半。

10. 可带走的Copy Anchor Link

1. map 查不存在的键返回零值不报错;分「不存在」和「值是零」用 comma ok。
2. nil map 不能写;delete 删不存在的东西是安全的;遍历顺序随机。
3. map 和切片是引用类型(共享),数组和结构体是值类型(拷贝)——但结构体里的切片/指针字段拷的仍是引用。
4. 嵌入 = 字段提升;提升撞名必须写全路径;Go 用组合替继承。
5. 方法接收者:只读值、改写指针;Go 自动补 & 和 *,但临时字面量取不了地址。
6. 没有构造器,惯例是 NewXxx() 返回 *T;小写字段 + 方法 = 封装。
7. 接口靠「凑齐方法」隐式满足,不用声明;这是 Go 多态的全部机制。
8. struct tag 驱动序列化:json:"-" 隐藏字段、omitempty 跳空值——API 里不漏密码就靠它。
9. 空结构体 struct{} 零字节,map[string]struct{} 是去重集合的惯用法。
10. 指针基本功:& 取地址、* 解引用;自引用结构体(链表/树)只能靠指针。

11. 原文地图Copy Anchor Link