range 和 switch 里藏着的几个坑

range 和 switch 里藏着的几个坑
隔壁老康难度 ★★☆☆☆ · 前置:切片传进去的到底是哪 24 个字节 | 一句话结论:range 和 switch 看着是控制流语法,实际上它们是两处最容易把复制和顺序藏起来的地方,而这两件事恰好是 Go 语义里最不能靠直觉的部分。
我接手过一个统计接口耗时的中间件,把每个请求的耗时塞进一个切片,最后算分位数。上线第一天就发现同一个接口重复调用五次,打出来的五个数字一模一样,我以为是缓存,查了半天缓存,没有,把日志加到每一行,发现那五个数字确实是从同一份数据算出来的,而那份数据的地址在五次里都没变过。最后定位到一行取址的地方,那个取址每次取的都是同一个变量的地址,这事发生在 2023 年,项目 go.mod 写的 go 1.19,那时循环变量确实复用。这不是 bug,是规范。我当时第一反应是语言有毛病,跑去翻规范,翻完发现错了,规范里写得清清楚楚,循环变量在循环开始时声明一次,每轮只是给它赋值,所以取址永远得到同一个地址。规范写得很清楚。这个语义跟 C 一样,跟老版 Java 一样,是那年代设计的语言共同的脾气,我用了七八年别的语言,一直没被它咬过,是因为那些语言的闭包捕获语义恰好帮我挡掉了大部分情况。
这类事情在 range 和 switch 里特别集中,两者都是看着眼熟、细节反直觉的语法,你越熟悉 C 和 Java,越容易在这里栽跟头。
我把踩过的坑整理成这一篇,每一个都有实测的输出,每一个我都能说出当时的现场,也都能说出改法和为什么那么改。
熟得越早,栽得越狠。
循环变量在 1.22 前后是两个东西
同一段代码,我把 go.mod 里的 go 行从 1.21 改成 1.22,输出就变了。代码是把三个元素的地址存进一个切片,再逐个解引用。1.21 的语义下,整个循环只有一个变量,每轮只是重新赋值,所以三个地址都一样,循环跑完它停在最后一个值 30,三个解引用都是 30。1.22 起,每轮循环都会新建一个变量,三个地址不同,分别是 10、20、30,这也是绝大多数人写代码时脑子里想的那个结果。这个改动的官方理由是有太多人在 goroutine 里闭包捕获循环变量,然后得到一个全是最后一个值的结果。这个坑我在 Python 里写过,JavaScript 的 var 也是这个脾气,凡是语言里存在这个设计,就一定有人在闭包里踩一次。Go 拖到 1.22 才改,是因为它承诺过语言规范的向后兼容,改这个语义等于改动规范本身,所以走了一个比较慢的流程,先在 1.21 里用一个实验开关让人试,1.22 才变成默认。
兼容是条硬线。
语言在慢慢收旧账。
关键在于,它由 go.mod 的 go 行决定,不是你装的 Go 版本决定。
B3 –> R2[“分别读到 10、20、30”]
这两件事都归在循环语义里,1.22 那一次把它们一起收了。
我本机是 go1.27.2,但一个写 go 1.21 的老模块,编出来的还是老语义。
用意是让旧代码保持旧行为,升级工具链不会悄悄改掉已有程序的运行结果,想换语义就自己改那一行。改那一行要谨慎。我见过有人升级时顺手把 go 行从 1.20 改到 1.22,然后一个用了很久的并发任务分发器行为变了。原来是把同一个变量指针派给所有 worker,worker 读到的都是最后一个任务,这个错误藏在一个任务只取一次的假设里,一直没暴露,改语义之后每个 worker 拿到不同的指针,反而把那个假设打破了,于是真正的 bug 才浮出来。所以改 go 行不是纯升级,它可能让藏着的错误变正确,也可能让藏着的前提失效,两种都发生过,而且都发生在我认识的团队里。值得单独说一句的是 1.22 顺手带来的另一个变化,整数也能 range 了,从零数到九写成一行就行。这个写法我第一次见的时候愣了几秒,因为它打破了 range 后面必须跟容器的直觉,但用顺手之后确实省掉了一个噪声很低的三段式 for(尤其是写测试循环的时候),十个用例一行开头,读起来干净。
1 | go 1.21: ptrs[0]=30 ptrs[1]=30 ptrs[2]=30 |
graph LR A1["1.21 第一轮 i=10<br/>地址 &i"] --> A2["第二轮 i=20<br/>地址还是 &i"] A2 --> A3["第三轮 i=30<br/>地址还是 &i"] A3 --> R1["三个指针全读到 30"] B1["1.22 第一轮 i=10<br/>地址 &i1"] --> B2["第二轮 i=20<br/>地址 &i2"] B2 --> B3["第三轮 i=30<br/>地址 &i3"]
range 到底复制的什么
for i, v := range x 这个写法里,x 在循环开始前会被求值一次,然后复制一份。复制的是什么,取决于 x 是什么类型,这一点跟值传递那篇是完全同一件事的两个侧面。对一个数组 range,复制的是整个数组。一百万元素的数组,range 一开始就复制一百万份,这是实实在在的开销,编译器不会帮你优化成按引用遍历,因为规范里写的就是复制,编译器没有权力自作主张。
1 | after modArrayInRange: [1 2 3] |
所以大数组一律用切片或者指针遍历,这一条不是风格偏好,是性能问题。我实测过一个含一千个 int 的结构体,它的尺寸是八千字节,传参要复制的就是这个数,一百次调用就是八百 KB 的栈上搬运,而同样的数据放在切片里传,复制的是二十四字节的头部,差了三百多倍。
复制一次,差三百倍。对切片 range,复制的是那 24 字节的头部。所以循环里改 v 不影响原切片,但改 x[i] 会影响,因为 x[i] 走的是指针加偏移,读写的是共享的底层数组。
1 | modify v: [1 2 3] |
这两行是我最常用来给别人解释的对比。v 是每一轮的副本,改它等于改一个临时变量,循环一结束就没了,x[i] 是直接写回底层数组,所以外面看得见。复制多少,决定了你能改到多少。map 的 range 复制的是那 8 字节的指针,但每次迭代给你的 key 和 value 也都是副本,所以改 value 一样改不回去,得写回映射里。
这一点在存结构体的 map 上特别容易错,因为结构体是值,改完就被丢掉了,编译器也不会警告你,它就静静地看着你改了一个马上要销毁的临时变量。
通道的 range 是个特例,它一直读到通道关闭为止,每次只给你一个值,没有索引。写 for v := range ch 的时候,循环不会因为通道暂时没有数据就退出,它会阻塞等,直到有人 close。这个语义很多人第一次见会觉得别扭,但它是消费通道的标准写法,配一个 goroutine 往里写,主流程读,是最常见的一对。
再往后一步,从 1.23 起函数也能 range 了,标准库里的迭代器接口就是靠这个落地,一个形如单参数回调的函数,只要回调返回 false 就提前结束。这个设计让自定义容器可以写得很轻,不用实现一堆接口方法,一个形如 yield 的回调就够了。
我拿它重写过遍历配置树的代码,原来要一个结构体和三个方法,改完只剩一个函数,调用方从二十行缩到七行。
代价是它不能中途返回错误,要传错误得靠闭包捕获或塞进回调参数,写库的时候要想清楚。
map 的顺序是被故意打乱的
我连跑了四次同一个五元素 map 的遍历。四次四个不同的顺序。这不是随机数没种好,是运行时故意的,每次 range 开始时会随机选一个起始的桶和一个桶内的起始偏移,然后按桶顺序走一圈。起点随机,走法固定。这么做的原因很实际,早期 Go 的 map 遍历顺序是稳定的,结果大量代码不知不觉依赖了这个顺序(比如按遍历顺序生成签名),等到 map 的实现一改,那些代码全炸了,而且炸的地方离原因很远,一个签名对不上的报错可能指向三天前的一次发布。打乱顺序之后,依赖顺序的 bug 会在开发阶段偶发暴露,而不是等某次升级才集中爆发。偶发比必然更难查,也更早暴露。所以任何需要稳定顺序的地方都得自己排。配置项按 key 排序再打印,签名按 key 排序再拼串,测试里比对 map 内容用标准库的比较函数。评审里看到有人直接遍历 map 输出,我会问一句顺序重要不重要。顺带说一个相关的数字。
同样是往 map 里写一百万个键,我测出来是 66.99 毫秒,换成预先给足容量的写法是 56.48 毫秒,差 1.19 倍。
这个差距全部来自扩容时的重新哈希,而扩容的触发条件跟装载因子有关,跟遍历顺序无关,两件事别混在一起。
顺序是故意不给你,四次跑四个样,这既是凭据,也是它敢这么做的底气。
1 | bcdefa |
字符串的 range 走的是 rune
注意索引跳了,从 0 到 1 到 3 到 6。这不是 bug,range 字符串给的是这一轮 rune 的起始字节位置,不是第几个 rune。é 占两个字节,所以下一个从 3 开始,世占三个字节,所以它在 6。需要第几个字符得自己数,标准库里有工具函数,但很多人拿索引当字符序号用。
九个数,因为整个串是九个字节。
按字节还是按字符没有默认答案,看切完交给谁用。
第一个数是字母 h,第二个数是 195,这是 é 的第一个字节,单独拿出来没有任何意义。
1 | s = "héllo世" |
1 | 按索引取字节: 104 195 169 108 108 111 228 184 150 |
这就是 Go 里字符串和字节切片界限最清楚的地方,字符串是按字节索引的,range 是按 rune 走的,两种视角混用就会切出半个字符。字节和字符是两套坐标。我处理过一个日志截断的问题,规则是超过两百字节就截断,实现按字节切到两百。
结果中文日志末尾出乱码方块,两百落在某个汉字中间,截出来的字节不是合法 UTF-8。
修法是按 rune 数一遍。边界不归你管。
这个 bug 在纯英文环境里永远不会出现,一到中文日志就必然出现。
switch 不穿透是默认
我从 C 那边带过来的习惯是每个 case 结尾必须写 break,不写就会掉到下一个 case。Go 里正好反过来,默认就不穿透,写了 break 是多余的。
第一分支里打印一行然后结束,不会掉到第二分支。想穿透得显式写 fallthrough,这个设计让绝大多数 switch 变短了,也少了一整类忘记 break 的 bug。C 里那个 bug 有多常见,看看各类静态检查工具里有多少条规则是查穿透的就知道了,那些规则不是凭空想出来的,每条背后都有事故。
既然默认不穿透,为什么还留着 fallthrough?少一层缩进,少一次回头。
1 | case 1 |
默认不穿透,省了一整类 bug。switch 还能带初始化语句,冒号前面先算一个值再拿它分支,这个变量的作用域只在 switch 内部,跟 if 的那个位置是一样的。
我第一次见到这个写法觉得别扭,用了几次发现它把算值再分支收在一行里,比先算再 switch 干净。
没有表达式的 switch 就是 if-else 链的另一种写法,条件从上往下求值,命中一个就停。
这是三级条件的输出,只打印了两行,说明第三个条件压根没求值。
这个细节在条件里有函数调用的时候很重要,把有副作用的调用放在 switch 的条件里,顺序决定一切。
1 | none evaluated |
习惯是负担,也是线索。
这一条是真正反直觉的。代码是第二分支写了 fallthrough 然后接第三分支,i 等于 2,第三分支的条件明明不成立,但它还是执行了。fallthrough 的语义是跳到下一个分支的语句体开始执行,它不重新判断条件。这一点跟 C 里没有 break 的效果一样,但 Go 把它写成了一个显式关键字,容易让人以为是试试下一个条件。
1 | 进入 case 2, i=2 |
它不是试试,它是直接跳进去,跳进去之后条件就再也不看了。它不是试试,它是直接跳。这个语义组合起来能写出很怪的代码,比如让两个分支走同一段收尾。这种用法本身没错,但一旦后面那一段又写了 fallthrough,就会一路掉下去。我给自己的规矩是它只允许出现在紧挨着的两个分支之间,中间不许夹注释、不许夹空行,因为一旦隔开,读代码的人就得回头确认上面那一行到底是不是它。
这条规矩执行了两年,我几乎没再写过,需要共享逻辑的时候直接抽一个函数,反而更清楚。
break 打断的是谁
外面是一个三次的 for,里面是一个 switch,case 里写了 break。三次全都打印了,说明那个 break 打断的是 switch,不是 for。这一条我在写一个找到就退出的循环时踩过。当时在 for 里套 switch,case 里写 break,我以为会跳出 for,实际只跳出了 switch,循环一直跑到自然结束。改法是给 for 打标签,或者把 switch 换成 if。
那次之后我养成一个习惯,嵌套超过两层就先想清楚每一层的出口在哪儿。
一层一层,谁也没说清。
找谁,比找得到更重要。
带标签的 break 和 continue 在 Go 里是正式语法,标签写在 for 前面,跳出外层就写标签名。
1 | loop body 0 |
这个写法在多层嵌套里很实用,代价是标签名要想清楚,因为一个函数里标签多了之后读代码要上下翻。标签是给读代码的人看的。标签还有一个用处是 continue 到外层,它会直接进入外层的下一轮,跳过内层剩下的部分。
三个出口,三种写法。
这个语义比 break 更容易搞混,因为它看起来像继续,实际是放弃当前这一整轮内层的工作,从外层重新来。我在一个把矩阵按行扫描的函数里用过这三个东西,外层是行,内层是列,遇到空行跳过整行,遇到哨兵值跳出整个扫描,遇到普通元素累加。
三个意图对应三种写法,放在一起是清楚的,但拆开任何一行单独看,都得回到顶上确认标签在哪儿、标的是哪一层。
这也是标签的代价,它把控制流的方向写在了名字里,而不在结构里。
一条判断
我把 range 和 switch 的坑归成两类,一类跟复制有关,一类跟顺序有关。
| 类别 | 具体的坑 | 你以为是 | 其实是 |
|---|---|---|---|
| 复制 | range 数组 | 逐个取元素 | 整份数组先复制一次 |
| 复制 | range 给的值 | 引用 | v 是副本,改它改不回去 |
| 顺序 | map 遍历 | 按插入顺序 | 每次跑都可能不同 |
| 顺序 | 字符串 range | 按字符走 | 按 rune 跳,索引不连续 |
| 顺序 | switch | 第一个真是的判断 | 求值到命中为止,后面不判 |
| 顺序 | fallthrough | 条件重判 | 直接跳进下一个 case 体 |
复制这一类包括 range 数组复制整个数组、range 给的值是副本、改 v 改不回去。顺序这一类包括 map 遍历打乱、字符串按 rune 跳索引、switch 求值到命中为止、fallthrough 不重判。这两类都不是语法书上会重点讲的东西,语法书讲的是怎么写,不讲为什么这么写的结果跟你以为的不一样,而这个差别恰恰是新手到熟手之间最疼的一段路,疼过之后你会开始怀疑所有看着眼熟的语法,那个怀疑本身比知识点更值钱。
怀疑是学习真正开始的地方。两类,一个根子。我把这几条写成一张便签贴在显示器边上,写了两个月,后来撤了。记住的标志是不再需要想。那两个月我用到的只有三条。












