短变量声明和 var,差别比你想的要大

短变量声明和 var,差别比你想的要大
隔壁老康难度 ★☆☆☆☆ · 前置:一个仓库放多个模块:workspace、internal 和 vendor | 一句话结论:
:=是在声明,=是在赋值,这两个符号的区别不在少写几个字,而在它决定了你这一行代码是在创造一个新东西还是在改一个旧东西,以及那个新东西能活多久。
我刚写 Go 的那几天,一直把 := 当成 var 的简写,因为这个理解在看代码时不出错,x := 1 和 var x = 1 确实干的是同一件事,看别人的代码也不会看错。这个理解在写代码时出了第一次错,报错是 no new variables on left side of :=,我盯着这行看了很久,因为在我看来左边明明有变量,怎么会没有新变量,我甚至去查了是不是某个变量名写错了,还去翻了一遍那个函数的返回值有没有被漏掉,又怀疑是不是自己把 := 和 = 敲混了,最后是我旁边那个人看了一眼说,你上面那行不是已经声明过了吗,我才反应过来这个符号要的是全新的名字。那一次的场面我印象很深,因为报错信息其实已经把答案写在脸上了,只是我当时脑子里装着错误的前提,看什么都看不进去。后来我把它拆开,才发现 := 这个名字里的短指的是短变量声明,它跟 var 的关系不是缩写关系,是两条完全不同的声明路径。
var 只做一件事,声明,它没有别的意思,你在哪里看到它,那里就一定诞生了一个新名字。
:= 同时做两件事,声明和赋值,而且它有个前置条件,左边至少要有一个名字是这一行新声明的。
这个前置条件就是下面三条规则里的第一条,另外两条说的是作用域和初始化顺序,三件事凑在一起,就出现了那种能编过的代码在骗你的场面。
短变量声明的三条规则
第一条规则是左边至少得有一个新变量。我实测了两种写法,报的是同一个错。同一个作用域里第二行的 x 已经不是新变量了,所以整行不成立。第二种是我把 var y int 写在前面再 y := 2,报的还是一模一样的一句,因为 y 也已经被声明过了。这两种情况的区别在于前者是同一行里重复,后者是跨行重复,编译器一视同仁。这条报错的措辞值得多看两眼,它说的是 no new variables,不是 redeclared(也就是说编译器并不认为你在重复声明),它认为你想声明但没声明成功。这两个说法的差别不是文字游戏,redeclared 意味着禁止重复,而 no new variables 意味着这一行本身不成立,你换种写法可能就成立了,比如把其中一个名字改成新的。这条规则有个容易漏掉的地方,它只管至少有一个是新的,不管其他几个是什么,也就是剩下的可以是老变量。这段能编过,输出 3 2 4。第二行的 x 是老变量,走的是赋值,z 是新变量,走的是声明,一行 := 里可以既有声明又有赋值,编译器按名字分别处理。这个设计我一开始觉得是妥协,后来发现它解决了一个真实痛点,就是那种要拿一个函数返回值、同时也要把错误写进外面那个 err 的场景,如果 := 必须全是新变量,那你就得先 var err error 再写两行。
第二条规则是作用域,表述很朴素,:= 声明的变量属于当前这个代码块,块结束了它就没了。
它是一个带条件的声明语句。
但代码块的边界在哪,比看上去的要细,if、for、switch、select 的分号前位置都是一个独立的块。
这条最容易被当成吹毛求疵。
那个分号前面的位置是一个独立的块,它的范围一直延伸到整个 if-else 链结束,所以 v 在 if 体内可见,在 else if 的体里也可见,出了这个链就没了。
1 | x := 1 |
1 | .\a.go:7:4: no new variables on left side of := |
1 | x, y := 1, 2 |
1 | if v := 10; v > 5 { |
1 | .\a.go:9:14: undefined: v |
还有一个更细的地方,裸块也算块,那对大括号没有关键字带着,它里面的变量跟外面毫无关系。输出 inner 2 和 outer 1。这个写法在实际代码里很少见,但它在提醒你一件事,作用域是跟着大括号走的,不是跟着关键字走的,任何一对大括号都是一个新世界。第三条规则是重复声明的判定按同一个块,不按同一个函数。这段能编过。第二层块里的 x := 2 是新声明,虽然外层已经有一个 x,编译器的判断只看当前块里有没有这个名字,外层有不算,因为它连外层的存在都不查。
这条规则的实现很直接,编译器在分析每个块的时候维护一个符号表,查重只查当前这张表,外层那张表在向下查找时可见,但在判重时不参与。
三条规则连起来看,:= 的行为就很清楚了,它在当前块里造一个新名字,左边全是已存在的名字就报错,一个能用的都没有也报错。
1 | x := 1 |
1 | x := 1 |
if 里声明的变量活不到外面
上面那个 undefined: v 是我第一次真的被作用域咬到。当时写的是一个查找函数,想在 if 里声明一个变量判断有没有结果,然后在 if 外面用它,结果就是编译不过。这个报错当时让我很恼火,因为 err 明明在上面那一行出现过。但编译器说得对,那一行的 err 属于 if 的头部块,出了这个块就没有了。这个设计的意图是好的,它让错误的检查范围被限制在需要它的地方,不会有一个 err 从函数头飘到函数尾、中间被反复覆盖,代价是你要在块外面用它就必须先在外面声明。我一开始觉得这是多此一举,后来写久了才发现它反而挡掉了很多错误处理上的糊弄,因为一个 err 不可能被声明一次然后在三个不相干的地方复用,每处都得各自处理,读代码的人就不会看到最后才发现这个 err 早被覆盖过三回了。
1 | if _, err := find(1); err == nil { |
1 | .\a.go:18:14: undefined: err |
有意思的是,这个限制反过来制造了一个更隐蔽的问题,也就是 shadow。输出 err = <nil>。外层那个 err 从头到尾没被赋过值,因为 if 里那个 err := 造了一个新的,f() 的返回值装进了新的那个,然后随着块结束消失了。这段代码如果 f() 真的返回了错误,外面看到的还是 nil,把 := 换成 = 才对。
这个 bug 的可怕之处在于它不报错,go vet 也不报,代码读起来还挺顺,因为同一行里既有返回值又有错误检查,看起来就是标准写法。
我后来养成一个习惯,只要看到 if 头部里有 := 而外面已经有一个同名变量,就停下来看一眼,这一眼基本能省掉一次排查。
1 | var err error |
1 | var err error |
包级与函数级的初始化顺序
包级变量的初始化顺序不是按文件顺序,也不是按你写的顺序,是按依赖顺序。这句话我一开始不信,专门做了一组实验,做完才发现自己对它的误解比对 := 的误解还深。
先看最基础的,一个包里有两个文件 a.go 和 z.go。
1 | a.go:A |
两个包级变量 A 和 Z 都没有依赖别人,这时候按文件名的字典序来,a.go 在 z.go 前面,所以先初始化 A 再初始化 Z。这个顺序是编译器决定的,文件名的字母顺序恰好也是这个顺序,很多人就误以为是按文件名排的,我在很长一段时间里也是这么以为,甚至在代码评审时说错过这个理由。那次我被人当场问了一句,那如果文件改名了顺序会变吗,我卡在那里,回来就写了那个改名实验。验证之后我发现依赖排序这件事是有代价的,编译器要为每个包建一张依赖图,图上没有边的时候才退回文件名顺序,因此你加一个依赖就可能悄悄改掉一整片的初始化顺序。真正决定顺序的是依赖。我把 X 的初始值写成依赖 Y 的表达式,Y 在 b.go 里,X 在 z.go 里,按文件名 b 在 z 前面。这个结果看起来还是没推翻我的假设,因为顺序刚好一样。我把两个文件改名再试,依赖关系照样优先(也就是说只要 X 的初始化表达式里出现了 Y),Y 一定先于 X,这跟文件叫什么名字彻底没关系,之前的吻合只是巧合。
依赖关系还可以链式延展,让 Z 依赖 X,X 依赖 Y,输出就成了三层的 Y、X、Z。巧合是最难拆穿的误解。
这个依赖分析有一个边界,它只看初始化表达式里直接出现的标识符,进了函数就断了。
两个 init 之间不该有依赖。
这段的输出变成了先 Y 后 X,而这次是因为 compute 这个函数被调用的时机,编译器并不会去分析函数体里用了哪个包级变量。
所以如果你想靠函数来封装初始化逻辑,依赖顺序就变成了运行时才确定的东西,编译器那层保护就没了,这一条我在写配置初始化的时候踩过,当时为了复用把一段逻辑封成了函数,结果配置文件还没加载完就被读了,拿到的全是零值,我还以为是文件路径写错了,查了两个小时才想到去看初始化顺序。
1 | var X = Y + 1 |
1 | b.go init, Y = 10 |
1 | var X = compute() |
这件事教给我一条经验,包级变量里不要调那种会读外部状态的函数,因为调用时机不由你控制。依赖分析的另一面是它会抓出循环。编译器比人先发现死结。
这条报错比运行时的死循环好得多,它在编译期就告诉你这两个变量互相等着对方。
1 | .\z.go:5:5: initialization cycle for A |
包的初始化顺序在包与包之间更简单,被依赖的包先初始化,这一条没有例外,因为不先初始化别人的包,你自己的初始化表达式根本算不出来。
1 | init sub.A 1 |
注意 init 函数全部排在包级变量之后,同一个包里先变量后 init,然后再看下一个包,但跨包的时候整个包先做完。
init 在同一个包里可以写多个,我写了两个分别在 a.go 和 m.go,执行顺序是按文件名来的。
这个顺序有个副作用值得记住,包级变量初始化完之后才轮到 init,所以 init 里能看到所有包级变量的最终值。顺序是 sub 的包级变量、main 的包级变量、sub 的 init、main 的 init、main。两个包的 init 谁先跑,凭什么定?
未使用变量和未使用导入为什么是编译错误
这一条是我觉得 Go 最有争议的设计。三个东西,局部变量、导入、参数,前两个不许不用,第三个随便不用。
1 | .\a.go:10:2: declared and not used: unused |
1 | .\a.go:5:2: "os" imported and not used |
这两条都是编译错误。而未使用参数随便写,编过运行,一点都不提示。这段编过,跑起来输出 ok。为什么前两个不行而第三个行(我后来想明白了),原因是用途不同。局部变量和导入是你主动引入当前作用域的东西,一个变量声明了却从没读过,那它要么是笔误要么是删代码时留下的残渣,导入的情况更明显,一个没用到的大包会让编译时间变长、二进制变大(这种代价没有任何好处),而且它是累积的,一个包多引一个大依赖,整条依赖链上所有下游都得跟着变慢。
我现在的做法是,如果这个 err 需要在 if 外面用,就不用 :=。
1 | func f(unusedParam int) { |
更麻烦的是一种隐形代价,有些包在 init 里注册了东西或者起了 goroutine,你只是随手引了一下没用上,那堆副作用照样会发生,这种事只有在追查内存或者 goroutine 泄漏的时候才会浮出水面。
参数不一样,参数是接口的一部分。这一条常被拿来当圣经。一个函数的签名写成什么样,是为了满足某个约定,实现里可能压根不看其中某个参数。
如果要求必须用上每一个,你就得写一堆 _ = req 来糊弄编译器,那不是改进,那是污染。
这个区别还能延伸出一个结论,未使用的局部变量是错误,但未使用的包级变量不是。
1 | var unusedGlobal = 42 |
这段编过。包级变量可以被包外的代码引用,也可以被反射或者链接器用到,编译器没法断言它没用,所以不管。这个差别还有一个实际后果,包级变量写多了不会有人提醒你,它会一直待在那里直到某次编译时间变长才被人注意到。
我在一个老项目里见过一个两百多行的包级变量区,全是早期留下的大 map 和测试数据,谁也不敢删,因为不知道有没有别处通过反射在用。
空白标识符是第三条路,_ = 5 这种写法告诉编译器我知道这个值没用、我是故意扔掉的,它就闭嘴了。第一段只取第二个返回值,第一个扔掉。第二段是上面讲过的部分重复声明,x 是老变量走赋值,err 是新变量走声明,这行能编过。
1 | _, y := two() |
1 | x := 1 |
说到 err 我又想起一件事,多返回值加 := 这个组合是 Go 里最容易写出 shadow 的地方,因为你写的时候脑子里想的是把 err 更新一下,实际上 err 如果在上层块里,这一行造的是新的那个。
八个报错,八个原因
| 你看到的现象 | 真实原因 |
|---|---|
no new variables on left side of := |
左边全是当前块已有的名字,:= 要求至少一个新名字 |
undefined: v(if 外面) |
if 头部声明的变量只活在那个 if-else 链里 |
内层 := 改了外层同名变量的值却看不出效果 |
内层造了新变量,外层那个根本没被赋值 |
| 包级变量初始化顺序跟文件顺序不一致 | 按依赖排序,依赖关系断了就按文件名 |
initialization cycle for A |
两个包级变量互相依赖对方的初始值 |
declared and not used |
局部变量声明了但没读 |
imported and not used |
导入了但没引用包里的任何东西 |
| 未使用参数不报错 | 参数是函数签名的一部分,属于对外约定 |
:= 这个符号我觉得是 Go 里设计得最矛盾的一处。它省掉了大量样板代码,让 x := 1 比 var x int = 1 短一半,但它同时把声明这个动作藏了起来,让读代码的人得先判断这个名字是新的还是旧的,而这种需要读者参与判断的语法,在别的语言里通常是反面教材。
我理解 Go 团队当时的取舍,他们要的是少写几个字符,代价是读者多花一点注意力。这个取舍在写小脚本的时候是对的,几十行的东西不值得为声明多占一行,但在几千行的包里,一个 := 到底是新变量还是老变量的差别,往往就是一次线上事故的起点。我的应对办法是把它标准化,凡是需要在块外面用的变量,一律 var 声明然后用 =,只在块内部用的变量才用 :=。这条规矩我守了两年多。这个规矩不完美,有些地方会多写一行,但它让每一行的意图都很明确,读的人不用想。写代码的时间只占一小部分,读的时间占大多数,这个交换我觉得值(尤其是在别人接手你的代码的时候),那个 var 摆在那里就是一句无声的说明,你不用读上下文也能知道这个名字是从哪来的。
多写一行的成本是几秒钟,少查一次的成本是几个小时。












