[!info] 关联笔记

• 所属 MOC：语言基础 · 学习路线
• 前置概念：流程控制、值与引用语义
• 并列概念：数组、Slice、Map、字符串、Channel
• 相关：闭包、Goroutine

Go range 语义

这个概念为什么会出现

遍历是日常操作，但不同数据结构的“遍历一个元素”含义不同：

• 数组/切片：按索引的有序元素
• 字符串：UTF-8 码点还是原始字节？
• map：键值，且无序
• channel：接收直到关闭
• 整数（1.22+）：生成 0..n-1

若语言为每种结构发明一套语法，会噪音大。Go 用统一的：

for i, v := range x { ... }
for v := range ch { ... }
for i := range n { ... } // Go 1.22+

真正的坑不在语法，而在：range 表达式求值次数、元素是否复制、迭代变量生命周期、遍历中修改集合。这些必须按规范理解。

[!abstract] 一句话理解 range 对表达式求值一次后按类型产生迭代值；元素位通常是副本；map 无序；Go 1.22+ 每轮迭代有自己的迭代变量，缓解闭包捕获老坑。

最小可运行示例

先把示例放进业务场景，再看代码：

场景：购物车行项目批量“加购 1 件”

后台任务遍历购物车 []Item，给每一行 Count++。
若写成 for _, item := range items { item.Count++ }，
改的是副本，落库/返回时数量完全没变——这是 range 最常见的业务事故。

正确写法：用索引写回 items[i]，或让元素本身是指针。
顺带对比 map 遍历：导出库存表时顺序不稳定，不能当排序结果用。

package main

import "fmt"

// Item 模拟购物车一行：商品数量。
type Item struct{ Count int }

func main() {
	// 两行购物车：数量分别为 1、2
	cart := []Item{{1}, {2}}

	// --- 错误：range 出的 item 是副本 ---
	// 业务本意“每行 +1”，实际只改了临时变量，cart 不变。
	for _, item := range cart {
		item.Count++ // 改副本
	}
	fmt.Println("after value-range bump:", cart) // [{1} {2}]

	// --- 正确：用索引写回底层元素 ---
	for i := range cart {
		cart[i].Count++ // 写的是切片里真正的 Item
	}
	fmt.Println("after index bump:", cart) // [{2} {3}]

	// --- map：键值遍历，顺序不保证 ---
	// 业务：打印 SKU 库存；不要假设先 a 后 b。
	stock := map[string]int{"sku-a": 1, "sku-b": 2}
	for sku, n := range stock {
		fmt.Println("stock", sku, n) // 顺序随机
	}
}

建议运行：

go run .

期望输出（map 两行顺序可能对调）：

after value-range bump: [{1} {2}]
after index bump: [{2} {3}]
stock sku-a 1
stock sku-b 2

结合场景再看三个关注点

1. for _, v := range 的 v 是拷贝
   改 v 的字段不会写回 slice/array；购物车加购必须用索引或指针元素。

2. 要突变元素 → 索引 / *T 元素
   cart[i].Count++ 或 []*Item 再 item.Count++。

3. map 遍历顺序故意不稳定
   展示层若要稳定输出，先把 key 收进切片再排序。

核心概念与准确模型

语法

for range expr { }
for i := range expr { }
for i, v := range expr { }
for i, v = range expr { } // 赋给已存在变量

• range 表达式在循环开始前求值一次（特殊优化：仅一个迭代变量且 len 为常量时可能不求值表达式，属规范允许优化）。
• 左侧至多两个变量；channel 与整数形式最多一个。
• _ 可丢弃。

各类型产生的值

range 表达式	第 1 个值	第 2 个值	顺序
array / *[n]T / slice	索引 int	元素副本 T	索引递增
string	码点起始字节下标	rune	按 UTF-8 码点前进
map	key	value 副本	不保证
channel（可读）	接收到的元素	—	接收顺序直至关闭排空
integer n（Go 1.22+）	0..n-1	—	递增；n<=0 则 0 次

nil slice / nil map：0 次迭代。
nil channel：range 永远阻塞。
已关闭 channel：读完剩余值后结束。

数组与切片

a := [...]int{10, 20, 30}
s := a[:]

for i, v := range s {
	// i: 0,1,2；v: 10,20,30 的副本
}
for i := range s { // 只取索引，可不拷贝大元素
	s[i] = s[i] + 1
}

对数组：range 使用的是 range 表达式的值（数组复制？）——若写 for i, v := range arr，规范下迭代的是 arr 的副本还是？

准确说：range 表达式被求值；对数组而言，若表达式是数组值，迭代在该值上进行。常见写法 range arr 会涉及数组值语义；大数组更常见 range arr[:] 或只要索引时 for i := range arr 避免多余元素拷贝关注点。实践：

• 大数组优先 for i := range arr 或切片视图。
• 需要改原数组元素用索引。

字符串：按 rune 解码

s := "Go语言"
for i, r := range s {
	fmt.Printf("%d %q\n", i, r)
}

• i 是字节下标，不是“第几个字符”。
• 非法 UTF-8：产出 utf8.RuneError（'�'），并前进 1 字节。
• 若要原始字节：for i := 0; i < len(s); i++ 或 for i, b := range []byte(s)（注意 []byte(s) 可能分配）。

map

for k, v := range m {
	// 删除尚未遍历到的键：不会出现
	// 迭代中新插入的键：可能被遍历到也可能不
}

• 每次遍历顺序可不同（从 Go 开始就有意随机化起点）。
• 不要依赖顺序；需要有序则取出 key 排序。
• 遍历中删当前键是允许且常见；插入行为不确定。

channel

for v := range ch {
	// 等价于不断 v, ok := <-ch；ok 为 false 时结束
}

• 生产者应 close(ch)，否则 range 永不结束。
• 只有发送方关闭。
• nil channel 上 range 死锁。

整数 range（Go 1.22+）

for i := range 5 {
	fmt.Println(i) // 0 1 2 3 4
}

• 需要语言版本 ≥ 1.22（go.mod 的 go 行）。
• range n 中 n 为常量或变量均可（类型为整数）。
• 替代部分 for i := 0; i < n; i++。

迭代变量语义（历史坑与 1.22）

经典问题：

var fns []func()
for _, v := range []int{1, 2, 3} {
	fns = append(fns, func() { fmt.Println(v) })
}

• Go 1.21 及以前：循环共用一个 v 变量，闭包几乎都打印 3。
• Go 1.22+：每次迭代创建新的 v，闭包捕获各轮值，打印 1/2/3。

工程注意：

1. 模块 go 行决定语言语义。
2. 读老代码/老教程时不要假设新语义。
3. 即使 1.22+，对“取地址 &v”仍要理解 v 是副本还是轮次变量。
4. 启动 goroutine 时，传参 go f(v) 仍是最清晰的跨版本写法。

副本 vs 写回

// 结构体元素
for _, item := range items {
	item.X = 1 // 无效写回
}

// 指针元素
for _, p := range ptrs {
	p.X = 1 // 改向的对象，有效
}

// map 的 value 是结构体副本
for k, v := range m {
	v.X = 1
	m[k] = v // 需要写回
}

设计动机

1. 一种遍历形态覆盖核心复合类型。
2. 值语义一致：迭代出的元素是值拷贝，避免隐藏引用惊喜（指针元素则另当别论）。
3. map 无序防止程序依赖哈希实现细节。
4. 1.22 每轮变量修复全社区最高频闭包 bug，而不引入新关键字。

边界情况与反直觉行为

1. range 表达式只求值一次

for i, v := range returnsSlice() {
	// returnsSlice 只调用一次
}

2. 遍历时修改切片长度

对切片：迭代次数在开始时由 len 确定（规范：对 slice/array 使用开始时的长度）。在循环里 append 原切片通常不会让本次 range 突然多轮；但通过索引改底层数据会影响后续读到的值。细节以规范与实验为准，生产避免边 range 边复杂变异。

3. 字符串 vs []rune

range string 解码 UTF-8；range []rune(s) 是先转码再按 rune 索引。

4. 只要索引时的性能

大结构体切片：for i := range s 避免每轮复制完整结构体。

5. channel range 与 select

for range ch 不能直接 case 多路；多路用 select + 手动接收。

6. 空组合字面量

for range []int{} / for range map[int]int{} 零次，不 panic。

常见误区

[!warning] 常见误区：改 range 的 value 期望改容器 错误：for _, v := range s { v = ... }。
正确：用索引、指针元素或写回 map。

[!warning] 常见误区：依赖 map 遍历顺序 错误：测试断言固定键序。
正确：排序 keys 或用全等集合比较。

[!warning] 常见误区：忘记 close channel 错误：消费者 for range ch 永久阻塞。
正确：发送方负责 close；广播用其他结构。

[!warning] 常见误区：跨版本假设闭包捕获 错误：同一代码在 1.21 与 1.22 行为不同却不声明 go 版本。
正确：固定 go.mod 语言版本并跑测试。

[!warning] 常见误区：把字符串 index 当字符序号 错误：i 当“第 i 个字”。
正确：i 是字节偏移。

与相邻概念对比

概念	差异
普通 for	完全自管初始化/条件/步进
切片/数组模型	range 读取方式；不改变描述符语义
闭包	与迭代变量生命周期强相关
反射遍历	reflect.Value 另一套，不属 range 语法

工程实践

1. 改元素：优先索引 for i := range s。
2. 大对象：避免 for _, big := range 无谓拷贝。
3. goroutine：go func(id int){...}(id) 显式传参（兼容且清晰）。
4. map 稳定输出：收集 key 排序。
5. channel：文档写清谁 close；多个发送方用 sync.Once 或协调器关闭。
6. 测试 map：不比序列化字符串顺序。
7. 字符串处理：算字符用 utf8/[]rune 并知分配成本。
8. go.mod 的 go 行 ≥1.22 再依赖新 range int 与每轮变量语义。

// 跨版本安全启动
for _, task := range tasks {
	task := task // 1.21 前的显式影子变量；1.22+ 冗余但无害
	go func() {
		process(task)
	}()
}
// 或更好：
for _, task := range tasks {
	go process(task)
}

可验证实验

实验 1：副本

结构体切片 range 改字段，打印原切片。

实验 2：map 顺序

连续三次遍历打印 key，观察是否变化。

实验 3：字符串下标

对含中文的 string range，打印 i 与 r。

实验 4：闭包

在 go 1.21 与 go 1.22 模块下分别运行“append 闭包打印 v”。

实验 5：channel

不 close 与 close 对比 range 是否结束。

实验 6：for i := range n

go 1.22 下 range 3 打印 0..2；range 0 无输出。

本节总结

• range 统一遍历语法；语义随类型变。
• 元素多是副本；map 无序；channel 直到 close。
• 1.22：整数 range + 每迭代变量。
• 最易错：当引用改值、依赖 map 序、跨版本闭包、字符串字节下标。
• 下一步：闭包 与 Channel 深入。

自测题

概念题

1. 为什么 for _, v := range s 修改 v 通常不影响 s？
2. range string 的第一个值是什么意义？
3. Go 1.22 对迭代变量做了什么改变？

代码推理题

m := map[int]int{1: 1, 2: 2}
for k, v := range m {
	if k == 1 {
		m[3] = 3
	}
	_ = v
}
fmt.Println(len(m))

len(m) 一定是 3 吗？遍历一定看到 key 3 吗？

工程思考题

要在测试中断言 map 序列化 JSON 与金线文件完全一致，为何脆弱？如何测？

参考答案

展开

1. v 是元素的拷贝，赋值只改副本。
2. 当前 UTF-8 码点起始的字节索引。
3. 每次迭代使用新的迭代变量实例，修复闭包/goroutine 捕获最后一轮值的老问题。
   代码题：len 在插入后常为 3；但 range 是否访问到新 key 3 不确定。
   工程题：map 无序导致 JSON object 键序可能变化；应比解析后的结构、或对键排序后序列化、或使用保证序的类型。

延伸阅读与资料来源

资料	类型	支撑
Spec — For statements with range clause	规范	各类型迭代规则
Go 1.22 Release Notes — Language changes	发行说明	每迭代变量、range over int
Go Blog — Fixing for loops	博客	循环变量语义变更背景
Tour — Range	教程	基础例子
Spec — String types / For	规范	字符串 UTF-8 遍历细节

---

笔记元信息

• 建议文件名：go-range-semantics.md
• 所属阶段：语言基础 / 数据遍历
• 学习顺序：控制流与复合类型之后
• 建议下一篇：闭包 或 Channel
• 本篇状态：已深化（规范 range + Go 1.22 语义）