函数返回了 nil,调用方却判不出来

难度 ★★★☆☆ · 前置:一个 interface 值占 16 字节,里面是两个指针 | 一句话结论:一个接口值要等于 nil,得类型指针和数据指针同时为空,而 nil 指针被装进接口的那一刻类型字段就填上了,于是判等永远为假。

有一次我给一个查订单详情的接口补日志,函数签名上返回 error,函数体里调了下一层存储,拿回来的 err 没做任何判断就直接往上走,最外层我照惯例写了一句判空,想着空就走正常分支,非空就把错误记下来再往上返回。

上线之后那个记录错误的分支一次都没进过,接口最后返回给前端一个空对象,前端同事截图过来问我这个订单为什么是空的,语气还挺客气,说是不是把测试库连到线上了。

我第一反应还在怀疑自己的查询条件写错了,把 SQL 和索引翻来覆去看了半天,越看越觉得没问题,因为同样的条件我在命令行里跑是能拿到数据的。后来我又去问了管订单表的那位同事,问他这张表最近有没有搬过家,他说这套库早就没人动了,只读从库用的也是同一份数据。

后来我把那行日志换成能打出类型的那种,把值本身和它的类型一起印出来,打印结果才露馅,一对括号,里面一个星号、一个类型名,后面跟着一个 nil。

意思是这个值属于某个具体指针类型,而它装着的那颗指针是空的。我一开始还以为是日志把类型打串了,特意把打印挪到 return 前面重跑了一遍,印出来的还是一对括号加一个 nil,连括号里那个星号的位置都没变。

看到那行我才明白自己判错了对象,我以为我在问那颗指针空不空,实际上我在问那个接口值空不空。这两个问题在源码里长得一模一样。

都是 err 加一个等号加一个 nil,编译器不会提醒你问错了题目,它只会老老实实回答你问的那个。

然后我拿着一个正确却无用的答案继续往下走,走到某个地方才发现路的尽头是空的。(那阵子我还在日志里搜过 nil 这个字符串,搜出来一堆,一条有用的都没有。)

它判的不是我以为的那个东西。这段代码短到能贴在一屏里,也不是什么偏门写法,两个变量,两次判等,没有函数调用,没有并发,也没有任何绕人的地方,差别只有一行,而我一直盯着别的地方看。

两个结果先摆出来,一行之差

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type MyErr struct{}

func (m *MyErr) Error() string {
return "my error"
}

var e error
fmt.Println(e == nil) // true

var me *MyErr
fmt.Println(me == nil) // true

var e2 error = me
fmt.Println(e2 == nil) // false
1
2
3
e == nil   true
me == nil true
e2 == nil false

三个变量,三种写法,答案却只有两个:

变量 写成什么 跟 nil 比
e var e error,从没赋过值 真
me var me *MyErr,空指针本身 真
e2 var e2 error = me,把空指针装进接口 假

第一个是零值接口,两个字段都是零,类型字段空着,数据字段也空着,判等一看类型字段是空就直接返回真。第二个我先定义一个空结构体当错误类型,给它挂上一个返回字符串的方法,让它满足 error 的要求,然后声明一个指向这个类型的变量,它是空指针,它自己跟 nil 比也是真的。第三步才是分水岭,我把这颗空指针赋给一个 error 变量,接口值再跟 nil 比,结果是假。第三个变量跟第二个变量指的不是同一样东西,e2 的类型是 error,它是一个接口值,里面装着那颗空指针,me 就是那颗空指针本身,判等是对容器做的,容器不空,答案就是不空。

十六个字节里,两个字段各管一段

真 nil 接口与 typed nil 接口的两个字段对比

要讲清楚为什么会这样,得回到接口值在内存里的形状。我用 unsafe 包里量尺寸的那个函数量过一遍,interface 这个类型是十六个字节,error 也是十六个字节,两者一模一样,因为 error 在编译器眼里就是一个方法集不同的接口,底层表示没有任何差别。

1
判等的顺序:先看类型指针,再看数据指针,两个都空才算空

这个顺序解释了为什么一个装着空指针的接口值怎么都判不成空,因为第一道关就没过,第二道关卡是什么值压根不重要。

空的是数据,不是类型。

1
2
fmt.Println(unsafe.Sizeof(e))   // 16
fmt.Println(unsafe.Sizeof(e2)) // 16

里面一个 itab 指针,一个 data 指针。

十六个字节在六十四位机器上正好两个字,一个字指向类型信息,一个字指向数据,这两个字段分开写,也分开读,判等的时候两个都要看,任何一个不合格,整个判断就不用再往下走了,我原来以为判等是拿数据指针去比,其实它连数据指针都没摸到就结束了,先看类型,类型有值,直接判假返回,后面那八个字节连读都没读。先看第一个字段,它记的是这个接口里装着什么类型,本质上是一张描述表的地址,表里放着类型名、大小、对齐方式和方法集这些东西,只要接口里装过东西,这个字段就一定有值,哪怕装进去的东西本身是空的,表还在,地址还在,它跟那颗空指针是不是空没有关系。再看第二个字段,它记的是数据在哪,具体怎么放要看类型,如果装进去的东西不超过一个字而且不需要取地址,值就直接塞在那八个字节里,如果是更大的东西,或者需要被修改、被外部看到,那八个字节存的就是一个地址,指向堆上或者栈上那块真东西。

我这次装的是一个指针,指针本身就只有一个字,所以第二个字段存的就是那颗空指针,八个字节全零,看上去空空如也,可第一个字段是有值的。

为了确认这个顺序,我在判等那一行上打了断点,一步一步跟进去看它先读哪个字段,跟到第二句就明白了,它连第二个字段的地址都没取,直接拿第一个字段跟零比。那第二个字段呢?它压根没参与这次比较,填什么都改变不了结论。

这条路我当时还走了个岔道。我以为是 GC 或者逃逸分析把接口值做成了某种特别的形态,专门去看了一眼逃逸分析的输出,发现跟判等一点关系都没有,该是两个字还是两个字。

两个都空,才算空。

把两个字段合起来看,规则就一句话,两个都为空,整个接口值才等于 nil。对照实测就很清楚,第一个变量两个字段都是零,所以为真,第二个变量是空指针,但它压根不是一个接口值,它跟 nil 比的是指针本身,所以也为真。

到了第三个变量,类型字段已经被填上了,数据字段虽然是零,可判等要求两个都零。这一点后来我在别的项目里又验证过一次,用反射把两个字段都打出来,那个存类型的字段确实有值。

类型字段一旦填上,判等就结束了

顺着这个形状往下推,能推出一个不太好接受的结论。只要一个值被赋给接口变量,类型字段就写死了,写死之后再怎么折腾数据字段,都改不了这个接口值不等于 nil 这件事,因为判等是两个条件的与,第一个条件先看类型,类型不为空,后面那个就不用看了。

类型字段填上之后,判等到底比的是哪几个字节?这也解释了为什么把一个空指针塞进接口之后,你没法用常规手段让它变回 nil,你可以把接口里的数据字段清掉,可以重新塞一颗空指针进去,类型字段仍然在,判等仍然是假,唯一的办法是把整个接口变量重新赋值成那个无类型字面量,那才是把两个字段一起清掉。

这一点跟我原来想的完全相反,我以为接口是个盒子,把东西拿出来盒子就空了,实际上盒子上的标签贴上去就撕不掉,除非你换一个新盒子。

return err 那条最普通的路径

项目里触发这个问题的路径其实非常固定,固定到我后来写代码时会条件反射地看一眼返回语句。最常见的一条是函数签名写的是 error,里面调下一层拿回一个具体类型的指针,没有做任何判断,直接把那个变量 return 出去,而这一层里没有任何一处写过判空。仔细看这一步发生了什么。下一层返回的是那个结构体的指针,它是一个具体类型,我在这一层接住它,变量声明成指针,然后我把它 return 出去,而我的返回类型是 error,这个 return 触发了一次隐式转换,编译器要把具体类型变成接口值,于是它把类型字段填成那张表,把数据字段填成那颗空指针。转换本身没有问题,编译器也不会拦,因为一个空指针转成接口在语法上完全合法,问题出在语义上,调用方拿到的是一个非空的接口,里面装着一颗空指针,库里那句判空骗的正是这件事。它没有说谎,它只是没有能力说真话,因为判等只能看见那两个字段,看不见你心里想的是哪一个。判空判在了错误的层上。这个坑还有一个更隐蔽的版本,方法本身用指针接收者,而你在某个分支里直接 return 了那颗 nil 指针,编译器照样帮你转成接口,照样不等于 nil,代码看起来比前面那种还整齐一点。

同一年我在同一个项目里又碰到一次,这回返回值声明成了 interface{},判空照样不生效(那次排查到半夜,才发现类型那一栏有值)。

我照着上一次的经验直接去看返回语句,几分钟就定了位,心里还挺得意,转头就在别人的 Code Review 里看到一模一样的写法,张了张嘴没说出话。

函数里写 return nil 反而没事

这一点第一次听会觉得反直觉。同一个函数,如果我写的是 return nil,问题不会出现,因为这里的 nil 是一个无类型字面量,当返回类型是接口时,它会被转换成接口的零值,两个字段都是空的,判等为真,而返回一个已经声明成具体指针类型的变量,走的是另一条路。两段代码只差一个词,一段返回变量,一段返回字面量,行为却完全相反。字面量自己不带类型,编译器能把它往任何类型上塞,塞给接口就是空接口,塞给指针就是空指针,而一个已经声明成具体指针类型的变量是有类型的,返回它的时候走的是转换,不是替换。这个区别在 Code Review 里几乎看不出来,两行都是一个 return 加一个词,只有读到上下文、知道左边那个变量在别处被赋成过空指针,才能判断。我后来养成一个习惯,看到 return 后面跟变量而不是字面量,就往上翻两屏,看它有没有可能在某个分支里被留成零值。字面量和变量,不是一回事。所以那个看起来更安全的收口写法其实并不安全,先声明一个具体类型的变量,后面在每个分支里给它赋值,最后统一 return 出去,只要有一个分支忘了赋值,那个变量就还是声明时的零值,这个零值一旦装进接口,就变成一个非空的接口。

这个习惯我维持到现在,凡是在别人的代码里看到 return 后面跟着变量,都会多停两秒,这两秒不费什么,漏过去一次,可能就是半夜爬起来看一个空对象。

errors.Is 展开的是错误链

遇到这个问题之后我第一个念头是换个判空函数,标准库里有一个 errors.Is,名字看起来比裸判等更懂错误。我试了一下,结果一样判不出来,因为它的作用不是把接口值拆开看两个字段,而是顺着错误链一层一层展开,用相等或者自定义的比较逻辑去问每一层。

换工具换不掉语义。

链上只有它自己一层的时候,拿它跟 nil 比,走的还是接口判等,类型字段照样参与比较,答案照样是假,指望换个函数绕过去是不行的。这一点我后来在别的地方也撞见过,标准库里不少函数的名字听起来像替你办了事,实际上它只是把某一类事办得更细。

在返回处先把 nil 拦掉

最稳的修法是在产生接口的地方把空值拦下来(也就是在 return 那一行之前加一句判断),如果这颗具体指针是空的,就直接 return 那个字面量,让无类型字面量去生成真正的空接口。这一句加在函数内部、加在类型转换之前,成本是一次比较,收益是调用方那句判空恢复了本来的意义。我的习惯是,凡是返回类型是 error 而手里拿着具体指针,都先看一眼这颗指针会不会是空的,会就写清楚,宁可多占一行,别让下游去猜。拦截要放在转换之前。如果这个函数是别人写的、改不动,那就把功夫花在调用方,一条路是拿到 err 之后先做类型断言,把它还原成具体类型,再拿那个具体值跟 nil 比,另一条是把判空的职责上移,不要指望 err 自己会空,而是从业务返回值里判断有没有成功。还有一条是从根上改,把下一层的返回类型从具体指针改成接口,这样每一次返回都会走一次统一的赋值,空指针进接口这件事在源头就被编译器和你自己盯着,少了一次隐式转换的机会。这两年我改成在函数开头就把返回值声明成具名变量,在每个分支里给它赋值,最后统一 return,这个写法本身也有坑,但只要每个分支都把 nil 处理掉,比在 return 那一行上判断更好读。

前提是整个包的人都认这条规矩,有一个人在外面又包了一层,顺手把指针塞进接口,前面的功夫就白费了。

我现在的排查顺序

现在再遇到判空不生效,我按固定的顺序走,不跳步:

  1. 看那个值的类型,带不带星号,带星号基本就能确定是这个毛病
  2. 看返回语句,返回的是变量还是字面量
  3. 看变量的声明类型,是接口还是具体指针

这三步都不用改代码,全在阅读层面完成,读完一遍基本就能定位,比在日志里追一个空对象便宜太多。真正花时间的是第四步(也就是决定改哪一层),改函数内部最省事,但如果有多个调用方,或者那个函数属于别人维护的包,就得改成调用方处理。