这几个版本到底替我省下了哪些代码

难度 ★★★☆☆ · 前置:unsafe 是一张随时会过期的通行证 | 一句话结论:这些版本真正替我省下的不是行数,而是我下笔之前得替语言想清楚、现在不用再想的那部分判断。

我是 2023 年 6 月入行的,第一天接手的就是一个 Go 服务,那时候对版本的理解只停留在装哪个工具链上。后来一段一段地读旧代码,才慢慢看出来每个版本都在把我抄过的东西往标准库里搬。

版本号我记不住,记得住的是形状。

循环变量那条改的是语义,旧代码也照样跟着变

这一篇讲的是我这几年一路跟过来的八个变化,先把它们摆成一张表,后面再一条一条说当时是怎么撞上的:

版本 变化 我先撞上的地方
1.21 min、max、clear 变成内建 工具包里那份 maxInt
1.21 slices、maps 进标准库 项目里那份排序去重工具包
1.21 slog 成为标准日志 线上那条只能正则捞的日志
1.22 循环变量每次迭代各自一个 定时任务里并发处理队列
1.22 for i := range 10 能直接写 一个只有上界的计数循环
1.22 math/rand/v2 新写的那个采样器
1.23 range 后面能放函数 自己写的一个遍历器
1.24 os.Root、AddCleanup、unique、weak 一个路径拼接的漏洞

go.mod 里那一行,凭什么决定运行时看到什么?第一次读到循环变量那条改动时,我的反应是去找迁移指南,因为在印象里版本升级要么加东西要么改语法,很少直接改掉一段已经能跑的代码所得的结果。go1.21 及之前,for 循环里那个 i 是整个循环共享的变量,三个协程里的闭包抱住的是同一个它,等调度器真把它们跑起来,循环早就走完了,所以打出来是三个 3。1.22 起每次迭代各自有 i,同一段代码打出来是 0 1 2,中间没有任何接口改名,也没有新增关键字,编译器照样放行。我一开始以为这是编译器偷偷替我把变量复制了一份,后来才想明白,复制发生在每一次迭代的开头,闭包捕获的本来就是那个新的变量,两件事其实是同一件,只是从代码上看不出来。这段代码我一行都没有改,编译器不报错,可它给出的答案换了。官方把这条修正挂在 go.mod 里的 go 版本上,本机是 go1.27.2 windows/amd64,可模块里写着 1.21,循环变量就还是共享的那一个,要确认自己站在哪一边,看模块文件第一行,而不是看本机装的是哪个工具链。我第一次被这件事咬到,是在一个定时任务里并发处理队列,本地怎么跑都是 0 1 2,部署上去变成三个 3,两边 go.mod 那一行不一样,而我当时只核对了工具链版本,没往下看第二行。那之后我养成了个习惯,新接手一个仓库先看 go.mod 第二行,那行字决定的是语义,跟装了哪个工具链没关系,同一个二进制换个编译参数就可能换一种结果,这件事我是被线上数据教会的,不是被文档。

1
2
3
for i := 0; i < 3; i++ {
go func() { fmt.Print(i) }()
}

手写的 maxInt 和摊开的 if 一起消失了

第二个变化来得更直接。min、max、clear 在 1.21 变成内建函数,以前要么在工具包里放一个 maxInt,要么在比较的地方把 if a < b 摊开写。这类函数代码只有一行,可每个项目都要有一份,参数类型从 int 换到 int64 就得再抄一个,抄到最后连命名都不统一,有人叫 maxInt,有人叫 intMax,新人进来先要花时间找哪一份是大家默认的。

1
2
3
4
5
6
func maxInt(a, b int) int {
if a > b {
return a
}
return b
}

现在直接写 max(a, b),参数几个都行,类型只要可比较,编译器自己推,也不用再为这一行去开一个新文件。

写一次少一次。

第一次在评审里看到 max(a, b),我以为是某个包里的泛型函数,点进去想看看它对相等的情况返回哪一个,点了两次都没找到定义,才反应过来这是内建函数,根本没有函数体可以点。

刚改过来那阵子我还有点不习惯,手会先去敲自己的工具函数名,敲完才想起来这个名字已经不需要了。删掉那一瞬间说不上高兴,只是觉得少了个牵挂。

它省掉的是一层包装。

clear 的位置容易被忽略,它把 map 里的键全部删掉,也把切片里的元素清成零值,区别在于切片清完之后长度还在,同一块底层数组之后还能继续用,不必重新分配。

我一开始以为 clear 会把切片截成空,清完照旧 append,长度会自己长回来。后来有一次清完直接交给下游,才发现 len 还是原来的数,多出来那一截全是零值。

这三个函数合起来省掉的是决策。以前写一次比较,要先决定这次要不要新起一个工具函数,函数放哪个包,参数用具体类型还是泛型,名字跟别人撞了怎么办,撞了之后是改名还是把别人的删掉。

这些决定单独拿出来看都很小,凑在一起就变成了新人第一个月的主要工作,因为代码本身不值钱,值钱的是判断它该放在哪。现在这些都不成问题,下笔时少想一层,读代码的人也不用去确认某个 maxInt 对相等的情况究竟返回了哪一个。

开销没有了,分歧也没有了,剩下的事情就是把逻辑写对,而这件事谁也替不了我。

slices 和 maps 进标准库之后项目里那份工具包空了

以前每个项目的工具包里都有一份排序、查找、去重,写法各异,有人收 []int,有人收接口,有人干脆用泛型重写一遍。1.21 给了 slices 和 maps 两个包,常用的一共就这几个:

函数 干的事 以前怎么写的
slices.Sort 原地排序 自己写 sort.Slice 加闭包
slices.Contains 判断有没有 手写一个 for 循环
slices.Index 找下标,找不到返回 -1 又一个 for 循环
maps.Keys 取出所有键 先 make 一个切片再填
maps.Clone 浅拷贝一份 同样的 make 加循环

签名统一,遇到没写过的函数顺手查一下文档就知道怎么用,不用再猜某个内部函数把空切片和重复元素当成什么。项目里那份工具包我没有删,只是再没有人往里加东西了,它安静地躺在那里,像一个没人再打开的抽屉。有一回我想给里面补一个函数,写到一半才反应过来,这个功能标准库里已经有了,而且名字比我起得短。顺带说一句 1.22 的 range over int,for i := range 10 直接能写,不用再起一个循环变量和一次比较,上界直接写在 range 后面。这些函数最省心的地方不是少写几行,而是少了一层猜测,读别人的代码看到 slices.Contains,我不需要先点进去确认它对空切片和重复元素怎么处理,标准库给出的答案只有一个,讨论可以停在这里。以前我接手一段代码,光是把工具包里的函数挨个读一遍就要花掉一个下午,因为每个函数的行为都要靠读实现来确认,文档里写的不算数。签名统一之后还有一个附带的好处,代码评审时没人再为内部工具函数的边界条件争论,评审的注意力回到了业务本身。1.22 的 math/rand/v2 是另一种收尾,新包和旧包并存,旧的 math/rand 还留着,老代码不用搬,新写的随机数从 v2 起手就行,两个包各管一段,互不打扰。

我唯一不太满意的是 maps.Keys 返回的是迭代器,第一次拿到手还想着像切片那样取长度,看了文档才知道得先 collect 一遍。

1
2
3
4
slices.Sort(nums)
if slices.Contains(nums, 7) {
fmt.Println(slices.Index(nums, 7))
}
1
2
3
for i := range 10 {
fmt.Println(i)
}

slog 上来之后日志的形状变成键值对

日志这件事我碰到的麻烦比语法多。1.21 之前,项目里要么用第三方库,要么自己包一层 log.Printf 再把键值拼成字符串,拼错一个分隔符,线上排查时就得对着两行文本猜哪个字段是请求 id,猜错了还要再回去翻调用点。

更麻烦的是每一层都自己拼一次,网关拼一遍,服务拼一遍,到了日志平台字段名对不上,对着一条链路要把三种格式的文本逐个对照,才能拼出一次请求的完整路径,而这件事本来不该由读日志的人来做。

升级之后,日志里吵的东西少了一半。

标签也好,键名也好,只要各写各的,同一件事在不同层就有不同的叫法。有一次对账,两边的日志时间都能对上,就是字段名一个叫 order_no 一个叫 orderId,对着看了半天才发现它们说的是同一个东西。

log/slog 进标准库之后,一条日志的基本单位变成消息加若干键值对,slog.Info 收消息和键值,输出格式交给 handler 决定,要 JSON 输出就挂一个 JSON handler,不必再往依赖列表里加一个包,也不用为了换个格式去改每一处调用点。

1
slog.Info("request done", "path", r.URL.Path, "status", code)

这一条改的是形状,不是功能。同一个包对旧代码也友好,log 和 slog 之间能互相转,老代码里那些 log.Printf 不用一次改完,两边同时在跑也不会打乱格式。

真正省下来的是约定。键值对写出来之后,字段名就成了团队之间要统一的东西,日志里该带什么不用在文档里列表格,看几行输出就知道。新人照着写也不会跑偏,因为形状是现成的,照着填空就行,不用先问一遍老人这段日志该怎么打。

以前我们为字段名开会,最后写成一份文档,文档半年就过期了,新来的人照文档写,查日志的人按印象查,两边对不上还要再吵一轮。

现在这件事不用吵了,形状本身把答案摆在那里,改字段名等于改输出,看一眼就知道谁没跟上。换 handler 也只动初始化那一处,调用点一行都不用碰。

range 后面能放函数,遍历变成了协议

1.23 里我一开始没看懂的是 range over func。函数出现在 range 后面,签名固定成 func(yield func(T) bool),迭代的一方每算出一个元素就调用一次 yield,调用方返回 false 就表示提前结束。标准库的 iter 包给这两种形状起了名字,iter.Seq[T] 是一条只出值的流,iter.Seq2[K, V] 是一条带两个值的流,写库的人给出形状,用的人只要会写 for range 就行,不需要知道里面是循环还是递归。

1
2
3
4
5
6
7
8
9
func Count(n int) iter.Seq[int] {
return func(yield func(int) bool) {
for i := 0; i < n; i++ {
if !yield(i) {
return
}
}
}
}

写惯之后会发现它的价值不在语法糖。自定义容器想被 range 遍历,不必再返回一个装满元素的切片,调用方也不被迫把所有元素一次性读进内存,算一个给一个,提前 break 之后剩下的也就不再算了。遍历变成了协议。代价是出错时的调用栈会多一层闭包,调试时得多看一帧,另外 yield 返回 false 的约定要守住,忘了 return 就会白算一轮。我自己的用法很保守,只在确实需要按需产出的地方写它,普通集合还是照旧用切片。协议是要守的。

unique 把重复收敛,weak 把引用放开

1.23 的 unique 包做的是把相同字符串收敛起来这件事。unique.Make 对同一个内容只保留一份,返回值再拿去比较时比的是指针而不是逐字节,标签、枚举、状态名这类大量重复的短串很适合走这条路。1.24 的 weak 包方向相反,它给出弱指针,指向的对象可以被 GC 回收,回收之后 Value() 返回 nil,拿它做缓存不用自己写淘汰策略,也不会因为缓存一直握着引用把内存撑住。这两个包一个收一个放,摆在一起才显得完整,因为它们处理的都是同一个问题,就是怎么在不增加括号的前提下让相同的东西少占一份内存。

前者假设内容会被反复读到,后者假设内容随时可能没人要,方向相反,出发点却一致。

1
2
3
4
5
h := unique.Make("order.pending")
p := weak.Make(obj)
if v := p.Value(); v != nil {
use(v)
}

它记的是指针,不是字节。这两条写的时候都不会让我少敲几行,省下的是后面查内存曲线的时间。用 unique 要注意它换的是比较方式而不是内容,读出来还是那个字符串。weak 的边界更明显,Value 返回 nil 就说明对象已经没了,拿到的值必须当场用掉,不能存起来等下次。我头一次写弱指针缓存,把 Value 的结果存进了一个变量,第二次用时它已经变成 nil,还以为是别人把数据删了。

os.Root 把路径关进一棵树,AddCleanup 挂在对象上

路径穿越以前靠手工拼 filepath.Clean 再判断前缀,拼错一次就漏一次,而且这种判断散落在每个接收文件名的地方,写的时候不觉得多。1.24 的 os.Root 换了个思路,os.OpenRoot 打开一个目录,之后所有的打开、创建、删除都从这个 root 出发,路径里带多少级上跳都出不去这棵树。边界交给运行时而不是交给我的字符串处理,也就不用再写那个前缀比较,更不用担心某条分支忘了判断。改完之后我删掉的那段判断有十几行,删的时候才意识到,之前每一次评审我都在替同一件事担心。同一版里的 runtime.AddCleanup 替掉的是 SetFinalizer,老接口一个对象只能挂一个清理函数,闭包一旦把对象自己包进去,对象就永远等不到回收,AddCleanup 允许同一个对象挂多个清理,传进去的是独立的值而不是捕获了对象的闭包。清理函数依旧不保证在进程退出时执行,它解决的是重复挂载和自引用,不解决时序(这一点想清楚再往上写),别把它当成 defer 的替代(我第一次就是照着 defer 的直觉去用的),结果进程退出时那个清理一次都没跑。那之后我把清理函数里该做的事都当成尽力而为,真正的收尾还是靠 defer 和信号处理,AddCleanup 只负责那些能被跳过的部分,别指望它替你把该写的 defer 写完。

它真正替掉的是那种一个对象上挂两个清理函数就得拆成两个包装类型的写法,现在直接挂两次,顺序是后挂的先跑。

1
2
root, err := os.OpenRoot(dir)
f, err := root.Open("a/b.txt")

容器里的核数与虚拟时钟,省掉的是环境假设

1.25 的两条改动省掉的东西不在代码里。容器感知的 GOMAXPROCS 让程序在容器里默认按 CPU limit 算并行度,不再按宿主机的核数算。

这件事以前要额外引一个第三方库,还得在启动时手动算一遍再赋值,漏掉一处就是整个服务按机器的核数开协程,容器里的配额和实际开出来的并发对不上,压测时看着很漂亮,上了线才发现一半的时间在等调度。测试那头的 synctest 把并发测试里的 time.Sleep 换成虚拟时钟,等待被直接跳过,不用再为了等一个 goroutine 跑完把测试拖长,它也从实验状态变成正式可用。这两条我都没有写过对应的代码,它们是替我省掉了在部署脚本和测试里反复做的判断。

环境假设不再靠猜。同一批里还有两条不算省代码的改动,1.23 修正了 timer 的语义,Stop 之后不需要再往 channel 里 Drain,未消费的 channel 变成无缓冲,1.24 的 encoding/json/v2 仍是实验状态,要开 GOEXPERIMENT=jsonv2 才能用,我没在线上碰过它。把这些排在一起看,我记住的不是版本号,是形状,每一项都能对上一段我确实写过、后来也确实删掉的代码,删掉之后行数少了,读的人少一层猜测。

语言把某件事定成标准答案,我就不用再跟同事争论谁那份工具函数写得对。