errors.Is 和 errors.As 到底在翻什么

难度 ★★★☆☆ · 前置:context 不是拿来传值的,是拿来传取消的 | 一句话结论:errors.Is 和 errors.As 都不比那个错误值本身,它们沿着 Unwrap 一层层往下翻,哪一层认出目标就停在哪一层,翻到底都翻不到才回假。

去年冬天我给一个查订单详情的接口补日志,存储层查不到记录的时候会返回一个包级的哨兵错误,我在中间包了一层,把查的是哪张表、参数是多少拼进描述里,再往上交给 handler。handler 里我写的是等号比较,比不中就按未知错误处理,给前端一句通用的失败提示。上线之后我盯了两天日志,那一支一次都没进过,每次都是兜底那一支,可兜底打出来的文本里写得明明白白,说没找到那条记录。我一开始还在怀疑日志级别配错了,翻了一圈配置没找出问题,又把 err 原样打到终端里看,那行字跟内层那句一字不差,只是前面多了一段我拼进去的表名和参数,于是我更加确信手上这个值和哨兵是同一个,毕竟打出来长得一模一样。那两天我绕的全是死路,文本相等和值相等压根不在一个层面上,我还觉得证据挺硬。还是旁边同事顺口问了一句你比的到底是哪个变量,我才回去看那行等号,它比的东西和我以为的不是同一个。等号比的是手上这个错误值本身,它不会掀开外面那层去看里面,包过一次之后,外层已经是一个新值,跟原来那个哨兵没有半点相等关系,连类型都可能换了一个。

包一层,等号就废了。这件事跟基础语法没关系,链在内存里是实打实的一串值,只是等号不认链,它只认眼前这一个,你拿最外面那层去跟最里面那层比,它只会老老实实回你一个假。

想顺着链走,得换成 errors.As。

哨兵错误躺在最里面,手伸不到那层

哨兵错误的好处是约定便宜,存储层把包级变量原样返回,调用方拿同一个变量比一下就知道发生了什么,不用再定义类型,也不用做断言。这类写法在标准库里到处都是,查不到、已经存在、权限不够,各自占一个包级变量,调用方按名字判断,源码里一眼就能认出来。这个约定在没人加包裹的时候一直很好用(我第一次在中间包一层时也没觉得有问题),编译能过,测试也是绿的。促使我加那一层的是一件很小的事,导出任务失败的时候运营只能看到一句没找到,不知道断在哪个库哪张表,我在描述里补上表名和参数再跑,报错立刻能看出断在哪一步,当时还挺得意,觉得自己把错误信息做扎实了。后来才发现测试里我比的是包过之后返回的那个值,压根没去比里面那个哨兵本身,所以它绿得毫无意义,只是又确认了我写错的比较,让我更加确信自己写对了。那段时间我一直拿打出来的那行字当证据,因为包过之后的文本里原样带着哨兵那句没找到,看上去分毫不差,我就默认值也是同一个。

(现在想想,那会儿我是拿肉眼看字符串,而不是让程序去认类型。)同一个仓库另一个调用点上,后面接手的人照着这段写了一次等号比哨兵,那个分支上线之后同样一次没走过,等出问题翻日志才被翻出来,错法和我那回一模一样。

下面这段代码和后面那几段输出,都是在我这台机器上跑的,版本是 go1.27.2 windows/amd64,跑法与上篇一致。

1
2
3
4
5
6
7
8
9
var ErrNotFound = errors.New("not found")

func FindUser(id int) (User, error) {
u, err := query(id)
if err != nil {
return User{}, fmt.Errorf("查用户 %d 时出错: %w", id, err)
}
return u, nil
}
1
2
find 0: not found
errors.Is(err, ErrNotFound) = true

把比较换成 errors.Is 之后同一段代码就通了,输出的第二行直接给了个真。递进去的两个参数,一个是套了层的壳,一个是最里面那个干巴巴的哨兵,长得一点都不像,它却认了。它比对的对象一直是当前这一层,不是最开始那个。

Is 沿着 Unwrap 一节一节往下摸

错误链一层层往下串

错误链这个说法听着抽象,形状其实很朴素,最外面一层是最后那次 fmt.Errorf 造出来的错误值,它内部记着一句描述和下一层的那个错误,想知道下一层是谁,就调它的 Unwrap 方法,拿到返回值再接着问,直到某一层的 Unwrap 返回 nil,链就到底了。errors.Is 走的正是这条路,它从最外层开始,先拿当前这一层跟目标比一次,不相等就问这一层有没有 Unwrap,有就往下走一层,再比一次,如此反复,任何一层比中就直接返回真,不用再往下走,所以链的长短不影响结论,只影响它要走几步。我这回套了两层,它就走两步。我一开始以为它会把整条链先摊平成一张切片再从头扫一遍,后来才看明白没有这一步,它就是拿一个变量从外层往下走,走到哪儿算哪儿,所以它对手里那一段的位置没有任何要求,你随便截一节进去都能问。这一点我后来用得很顺手。链条是靠 Unwrap 串起来的。能当链上一节的东西只有一个要求,实现一个叫 Unwrap 的方法,返回值是 error,别的都无所谓。

自己定义的错误结构体如果没写这个方法,包它也只是把里面的值塞进一个字段,errors.Is 走到这一层就再也下不去了。手写这个方法的时候,返回的应该是你手里那个内层错误,返回错了或者返回 nil,链就断在你这一节,外面再怎么找都找不着底下那层。

我第一版就写反过一次,把外层的描述又包了一层当成内层返回出去,本地看不出任何异样,等有人拿 Is 去判断的时候才发现,一层层都问过,一个都没认出来。

某一层可以自己决定认不认

顺着链走的时候,errors.Is 在每一层还会做第二件事,看看这一层的类型有没有实现一个叫 Is 的方法,签名收一个 error 返回一个布尔。有就调用它,让这一层自己回答认不认,这个钩子留给那些没法用相等来判断的错误(比如一个错误结构体内部只存了一个码),两个值不相等,语义却是一样的,硬拿等号去比,永远比不中。顺序是先比相等,不相等才去问这一层,所以实现了这个方法的类型,两种判法都算数。这里有个容易忽略的地方,这个方法收到的是你递给 errors.Is 的那个目标值,不是最内层那个哨兵,所以它自己得能认得出目标长什么样,写的时候要按目标的样子去比,不能拿自己身上的字段去猜。我第一次实现这个方法的时候就在这上面栽过,方法里比的是自己身上那个码跟参数里的码,测试里两个值恰好码相同,绿了,真跑起来才发现认的是另一个对象。认不认,这一层说了算。

组里那个带错误码的类型就用了这招,它的描述文字里塞了请求 ID 和时间戳,两个值永远不可能相等,于是组里写这个类型的人给它挂了个 Is 方法,只要码一致就认,外面不用知道它内部长什么样。我第一次看这段代码还觉得别扭,觉得错误类型不该反过来判断别人递过来的东西,用了一段时间才转过弯来,判断权本来就该放在最清楚语义的那一层。

我后来给别人讲这段,对方第一反应也是别扭,说错误类型凭什么替别人做主,等他自己的库里也出现同码不同文的情况,才回头把这个方法补上。

As 要的是类型,所以得递一个地址进去

errors.As 看着跟 Is 很像,但第二个参数不是值,是个指向目标类型的指针。它走的是同一条链,做的是另一件事,每到一个新的层就试着把这个错误值装进你指定的那个类型里,装得进去就停下,把值写进你递进去的那个指针,然后返回真。指针是让它往外写。

1
2
errors.As 到 QueryErr = true, Table = users
errors.As 到 TimeoutErr = false

两行放在一起看就很清楚,第一行装进去了,顺手把 Table 那个字段写了回来,第二行是我故意拿一个不对的类型去问,链上没人长得像它,所以是假。这个假不是出错,只是没找到,找到和没找到都是正常分支。

同一个 As,接口也能装得下

As 的目标不一定是个具体类型,也可以是个接口,只要链上某一层的错误值实现了这个接口要求的方法,它就能装进去,不关心那个值到底是哪个包定义的。这一点跟认结构那条路正好相反。

这个能力在做分层处理的时候很顺手,上层不需要知道下层用的是什么类型,只需要问一句这个错误能不能等一等再试,能就重试,不能就往上报,两层代码之间除了那个接口没有别的耦合。所以先用 errors.As,别急着断言。

标准库里的 net.Error 就是这种用法,外面包了一层还是两层都无所谓,只要链上有人实现了那个方法,这个判断就能成立,写调用方的人不用去翻下层的类型定义。

我在自己那段代码里也这么用过一次,效果是把一个判断从五六行类型断言收成了一行,后来新加的几种错误只要实现了同一个方法,不用改那个判断。新错误加进来的时候那个判断一次都没动过。

Is 那条路只看方法,不看类型名。

判断规则就一条,方法集够不够,够就装得下,类型名根本不在考量范围内。这跟具体类型那条路是一样的,只是检查的东西从结构换成了方法表。

1
errors.As 到接口 Timeout() = true, tt.Timeout() = true

两行都是真,后面那个 tt 是从指针里取出来的接口值,调它自己的方法拿到的结果跟预想的一致。装进去之后你手里还是个接口值,想调它自己的方法还得再断言一次,这一步别省。

%v 只拼文字,%w 才把下一层挂上来

这两个动词的差别,在错误处理里是性质上的差别:

动词 造出来的东西 还能不能找回去
%v 描述加内层文本拼成的新字符串 不能,原来的错误值没了
%w 带一个内层字段、实现 Unwrap 的新错误 能,errors.Is 顺着链摸下去

用 %v 的时候,fmt.Errorf 把你的描述和内层错误的文本拼成一个新字符串,再拿它造一个全新的错误值,内层那个错误值就此消失,只剩下几行字。

用 %w 的时候,造出来的错误类型里多带一个字段,专门存着内层那个错误,并且实现了 Unwrap,把存着的东西原样还回去,链就是这么接上的。前者是抄了一遍内容,后者是把原件挂在身上。抄下来的那份,再怎么翻也翻不回去。

套了三层之后,栈里只剩最后加的那句。

差别不在排版,在还能不能找回去。两种写法打出来的文本长得几乎一模一样,得拿代码去认才能分清,所以它特别容易在上线之后才暴露,本地测试时一切正常。%v 只是拼了段文字。

1
%v 版本 errors.Is = false, %w 版本 = true

同一段逻辑只改一个字母,结论就翻过来,因为 errors.Is 认的是链,不是字面。一个 fmt.Errorf 里可以出现多个 %w,每出现一次,这一层就挂上一条链,errors.Is 在每条链上都会找一遍,直到其中一个命中,所以几个 %w 不是拼在一起,是并列挂了好几条。

1
双 %w 输出 both: not found and base, 两个 errors.Is 都 true

两条都真,说明第一条链没命中时它没停下。

而是把每一条都走了一遍,只要其中一条命中就算数。多挂几条链有它的用处,一个错误同时属于两类问题时不用二选一,可别为了这个把链挂成一棵树,读日志的人会疯,包错的人自己都记不住哪一层挂了什么。

typed nil 让 Is 也跟着失灵

前面那些坑都能靠换个函数绕过去,这个坑绕不过去,它出在值本身。先看输出,e2 和 me 在我眼里是同一个东西,一个判空是假,一个是真(我第一次看到这组结果的时候),还以为是编译器哪里搞错了。毕竟同一个东西怎么会一会儿空一会儿不空。

照原样重写了一遍,跑出来还是这两个值。那天下午我盯着这两行看了很久,因为它们长得太像,区别只在被谁装过,我把它们的类型分别打出来对着看,才慢慢看出差别不在值上。nil 也有两副面孔。

1
typed nil: e2 == nil 是 false, me == nil 是 true, errors.Is(e2, nil) 是 false, e2 打印 my

根子在一个接口值要等于 nil,得它的类型字段和数据字段同时为空。那颗空指针被装进接口的那一刻,数据字段确实还是零,可类型字段被填上了,因为编译器得记住这里面装的是哪个类型,不然将来调方法的时候找不到。

两个字段只要有一个不空,整个接口值就不等于 nil,判等先看类型,看一眼就结束了。这一点跟判断两个普通指针是不是 nil 完全是两回事,后者只看一个机器字,前者要看两个。判断的时候两个字段都得看,少看一个就会把空指针当成非空。

我后来在纸上画了一次这两个字段的分布,才算把这件事记牢,之后每回看到一个返回 error 的函数,都会先问一句它可能返回的是不是一颗空指针,如果是要么在函数里就把它挡掉,要么在调用方那侧单独判一次。

errors.Is 那一行也救不了,因为目标传的是 nil,它压根不进链,直接拿两个值判等,结果跟手写等号一模一样。

判空这一步没有捷径可走,判别函数替不了,只能自己动手。

这个坑我在代码评审里又见过两次,都是返回 error 的函数最后一行写着 return nil,可那个 nil 被塞进了一个具体类型,调用方一判就觉得非空。后来我们干脆把这类函数的返回值都过一遍 vet,能抓一部分,剩下的靠人盯。接口里装着一个 nil 指针,它为什么不算 nil?

每包一层都要多付一次钱

包裹是有成本的,每包一层就多一次分配,也多一层调用栈,这两样在热路径上都是实打实的开销,请求量一上来就压在延迟尾巴上。更要紧的是文本,链太深的时候一行日志能顶掉屏幕半屏。

包裹要付代价。我们现在的约定是跨层包一次,同层里不重复包,描述里只写这一层能确定的事。这条约定写进代码规范之后排查反而快了不少,顺着链读下去就是一条完整的因果。