错误是返回值:`if err != nil` 在做什么

错误是返回值:`if err != nil` 在做什么
隔壁老康难度 ★☆☆☆☆ · 前置:接口:方法对得上就能装进去 | 一句话结论:Go 没有异常,出错时函数把错误当成排在末尾的返回值递出来,
if err != nil就是伸手接住它的那一下。
我做的第一个带输入输出的程序是从一个 CSV 里读订单。写完 f, err := os.Open(path) 之后,我盯着第二个返回值想了很久,写了个自以为聪明的分支,能打开就往下走,打不开就打一行日志。结果程序在完全正常的那一趟里也打了日志,日志里只有一个尖括号包着的 <nil>。我第一反应是文件读坏了,跑去查路径、查编码、查文件名末尾有没有看不见的空格,折腾到半夜才反应过来,那行字说的是相反的意思,它说的是这一趟没出事。nil 就是错误不存在本身,不是没有这个值,是这个值是空的。
nil 不是没报错,是报错这件事不存在。
那个 err 变量里装的不是 error
error 在 Go 里是个接口,定义只有一行,type error interface { Error() string }。你手上那个 err,声明出来的类型是 error,但里面装的一定是某个具体类型,因为接口自己造不出值来,它只是一张清单,写着想进来必须会哪个方法。这句话拿两行代码就能验,用 errors.New 造一个错,再用 %T 把真正的类型打出来,两次打印一模一样,装进接口不换内容,只是允许你把它当 error 用。那个 *errors.errorString 是 errors 包内部的小结构体,里面就装着一句字符串,Error() 把它原样返回。你不需要知道它长什么样,也不需要把它断言回那个类型,手上这个 err 就是个盒子,能做的只有一件事,调它的 Error() 拿到那句人话,剩下什么都没有。
1 | err := errors.New("something failed") |
1 | $ go run . |
造错的两个入口
造错的两个入口都在标准库里。最省事的是 errors.New,递进去一句人话,它给你一个错误值,这句话以后就是 Error() 的返回值,改不了,也带不了任何上下文。要带上这一层知道的信息,就用 fmt.Errorf,参数和 Printf 一样,末尾那个动词决定要不要留后路,这个后路下面再讲。
1 | _, err := os.Open("不存在.txt") |
1 | $ go run . |
同一件事从不同层返上来,长得完全不一样,因为每层都往里塞了自己知道的那点东西。*fs.PathError 这个类型里有三个字段,Op 是刚才在做什么,Path 是对谁做的,Err 是底层真正的原因,Error() 把三段拼成一句。写代码时选哪个入口,看这一层知道多少。底层只知道自己失败了,就 errors.New,或者把系统给的那个错误原样往回递,上层知道刚才在干什么,就用 fmt.Errorf 把那件事拼在前面。我自己有过一段反过来写的时期,底层什么都往上拼,上层反而只剩一句失败,回头看日志的时候一句有用的都没有。
| 谁造的 | 典型类型 | 文本长什么样 |
|---|---|---|
errors.New |
*errors.errorString |
你自己写的那一句 |
fmt.Errorf 加 %w |
*fmt.wrapError |
你的模板再接上内层文本 |
| 标准库 | *fs.PathError 一类 |
操作、对象、原因,三段拼起来 |
错误的信息量该随层数往上长,不是换一层把同一句话重复一遍。
它为什么排在末尾
返回值里有一个是 error 的时候,它一定排在末尾,前面那些是你要的东西,末尾那个是要不要停下来的信号。这条规矩不是编译器定的,我把 error 挪到第一个返回值真跑过一次,能编、能跑、go vet 一声不吭,所以它纯粹是约定,而约定能立住是因为读代码的人有个稳定预期,眼睛扫到参数表末尾就能判断这个函数会不会失败。成功和失败各跑一次,差别只在那个位置上:成功那一趟 err 就是 nil,判一下直接往下走。失败那一趟第一个返回值是空的,出错的函数通常没法给你半个结果,[]byte 给的是 nil,int 给的是 0,谁都不保证能用。所以拿到 err != nil 就当场返回,别去看前面那些值,它们在这个时刻没有任何意义,拿来拼日志只会误导人。
1 | func readFile(name string) ([]byte, error) { |
1 | $ go run . |
判断只有一行:if err != nil
判空就一行,if err != nil。
看着太简单,坑都在 nil 打出来是什么样上面。同一个空的错误值,%v 给你 <nil>,%s 和 %q 不认识它,给你一个带感叹号的占位符。这些都还算客气,你要是想调它的方法,程序当场就崩。
1 | var err error |
1 | $ go run . |
前两行还好,第三行直接崩,因为 nil 接口身上没有方法可以调,它是个空盒子,Error() 不在里面。%s 拿不到字符串也只是打一个占位符,不会停,所以真正危险的不是那些感叹号,是崩溃。判空只能用 == nil 或者 != nil 这种直接比,不能先调一下再看看,这一行写得对不对,区别是崩溃在源头,还是崩溃在两百行之外的另一个包里。
空盒子上调不到方法,判空只能拿它跟 nil 比。
不接这个返回值会怎样
不接这个返回值,没人会拦你。
把 os.Open 的返回值整个丢掉,编译能过,go vet 一声不吭,程序退出码还是 0。文件没打开,错误消失了,后面拿着一个空的句柄往下读,崩在别处,栈里跟源头一点关系都没有。这是 Go 里最典型的一种事故,它不报警,只是把问题往后推,推到你看不出因果的地方。
go vet 有个检查项专门管没被使用的返回值,但它只认一份写死的名单。同一份代码里,把 errors.New 的返回值丢掉它就会报。
1 | errors.New("没人接") |
1 | $ go vet ./... |
名单上有 errors.New、fmt.Errorf、fmt.Sprintf,os.Open 不在上面,所以同一个动作换个函数就没人管了。这套检查覆盖得并不全,社区才有 errcheck 这类外部工具补位。接了返回值但不使用是另一档,那归编译器管,直接编不过。
1 | $ go build |
三档反应摆在一起,就是 Go 的 errcheck 文化。编译器管你有没有把它赋给变量,go vet 管一份名单,剩下的靠人和外部检查器盯。
| 你做的事 | 谁管 | 结果 |
|---|---|---|
os.Open 的返回值整个丢掉 |
没人管 | 编过、vet 沉默、错误消失 |
| 接了返回值但一次没用 | 编译器 | declared and not used |
errors.New 的返回值丢掉 |
go vet |
result of errors.New call not used |
啰嗦的判空不是形式主义,是把链续上。
包一层:%w 加壳,%v 只会拼字
底层返回 disk full 的时候,你不知道是哪个文件写不进去,所以中间那一层要包一次,把文件名拼上去。包的动作就是 fmt.Errorf 加一个动词,动词选 %w 还是 %v,决定了外面还能不能找回里面那个值。
1 | base := errors.New("something failed") |
1 | $ go run . |
一个字都不差,类型不一样。%w 造出来的 *fmt.wrapError 身上多一个字段,专门存着内层那个错误,还实现了 Unwrap,把存着的东西原样还回去。%v 造出来的就是个普通字符串错误,内层已经被拼成文字了。区别要拿判断才能看出来。
1 | fmt.Println("errors.Is(wrapW, base) =", errors.Is(wrapW, base)) |
1 | errors.Is(wrapW, base) = true |
同一段逻辑只改一个字母,结论就翻过来。%w 那一版能顺着链摸回最里面那个值,%v 那一版摸不回去,Unwrap 给它一个 nil,说明这一层底下已经没东西了。这是本篇最要紧的一次对照,记住的不是哪个动词高级,而是包错的时候你以后还想不想判断这个错是什么。判断错是哪一种、想取出某个自定义类型,都得靠这条链还在,链断了,只剩一句拼好的文本,谁也认不出里面原本装的是什么。反过来有一种情况确实该用 %v,那就是这一层的库不想让调用方依赖内层的具体值,只想递出一句人能读懂的话,那就干脆不留链,把内层降成纯文本,别人也就没法拿 errors.Is 去问里面是什么。所以选动词的时候问自己的不是哪个更高级,而是外面那一层还有没有机会追问里面。
链长了两层之后,errors.Unwrap 一次只剥一层,剥到第三次拿到 nil,说明到底了。
1 | l1 := fmt.Errorf("write %s: %w", "a.log", base) |
1 | $ go run . |
fmt.Println 打出来的是最外面那句话,中间那几层已经拼进文字里,所以看上去是一整句。想看清楚结构,换 %+v 也没用,它跟 %v 打出来的东西一模一样,Go 的错误没有那种把整条链展开的格式化动词。要看结构只能自己一层层 Unwrap,或者交给 errors.Is、errors.As 去问。
1 | $ go run . |
两个错误同时发生、两个都得报的时候,用 errors.Join 把它们合成一个,判断对两边都成立。
1 | e1 := errors.New("读配置失败") |
1 | $ go run . |
壳能一层层剥下去,拼成文字的那部分再也剥不回来。
自己的错误类型,用 As 取回来
有些错误要带字段。比如查不到用户,你要把状态码和那句人话一起带出去,定义一个结构体,给它挂一个 Error() string 方法,它就算一个错误类型了。
1 | type MyError struct { |
方法接收者写的是 *MyError,所以只有指针满足 error,值不行,我第一版返回的是 MyError{...},编译器当场拦下来。
1 | $ go run . |
包了一层之后,想知道里面是不是这个类型,用 errors.As 取回来。第二个参数传一个指向目标类型的指针,找到就把值写进去,找不到就返回假,那个指针还是 nil。As 会顺着 Unwrap 一路往下找,外面裹了几层都不影响。
1 | err := fmt.Errorf("加载用户页失败: %w", query()) |
1 | $ go run . |
panic 不是错误的另一条路
panic 一按下去,程序立刻停。
它先把栈打出来,从崩的那一行一层层往上,每行都带着文件路径和行号。
1 | func main() { |
1 | $ go run . |
想接住它得靠 defer 加 recover,recover() 的返回值就是你 panic 时递进去的那个东西,类型都还在。
1 | defer func() { |
1 | $ go run . |
接住之后程序还能往下跑,但崩的那一行已经回不去了,栈也断了,所以它只适合兜底,不适合当控制流。拿它当分支用,读代码的人会以为这里真的出了要命的错。
判断一个错误该不该 panic,问一句上层有没有办法处理它就行,能处理就返回 error,处理不了才让它炸。
平时打日志用 log.Printf,它替你加上时间戳,%v 会去调那个错误的 Error(),包过的整条链的文字都在里面。
1 | err := errors.New("连接被拒绝") |
1 | $ go run . |
log.Fatal 打完就调 os.Exit,注册过的 defer 一个都不会跑。
1 | $ go run . |
这篇讲的东西都不难,难的是把它们连成一条习惯:函数末尾返回错误,中间每层想加信息就用 %w 包一次,调用方在每一层都判一次空,判到就往上走一层,在某个地方打一行日志。整条链上,错误值一直在,位置也一直清楚。
下一篇讲包和模块,一个项目怎么分目录、import 后面那串路径到底指到哪。












