错误是返回值:`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
2
3
4
5
err := errors.New("something failed")
fmt.Printf("err %T\n", err)

var e error = err
fmt.Printf("装进 error %T\n", e)
1
2
3
$ go run .
err *errors.errorString
装进 error *errors.errorString

造错的两个入口

造错的两个入口都在标准库里。最省事的是 errors.New,递进去一句人话,它给你一个错误值,这句话以后就是 Error() 的返回值,改不了,也带不了任何上下文。要带上这一层知道的信息,就用 fmt.Errorf,参数和 Printf 一样,末尾那个动词决定要不要留后路,这个后路下面再讲。

1
2
3
_, err := os.Open("不存在.txt")
fmt.Printf("%T\n", err)
fmt.Println(err)
1
2
3
$ go run .
*fs.PathError
open 不存在.txt: The system cannot find the file specified.

同一件事从不同层返上来,长得完全不一样,因为每层都往里塞了自己知道的那点东西。*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
2
3
4
5
6
func readFile(name string) ([]byte, error) {
if name == "" {
return nil, errors.New("名称不能为空")
}
return []byte("hello"), nil
}
1
2
3
$ go run .
"hello" err=<nil> err==nil: true
"" err=名称不能为空

判断只有一行:if err != nil

判空就一行,if err != nil。

看着太简单,坑都在 nil 打出来是什么样上面。同一个空的错误值,%v 给你 <nil>,%s 和 %q 不认识它,给你一个带感叹号的占位符。这些都还算客气,你要是想调它的方法,程序当场就崩。

1
2
3
4
var err error
fmt.Println("err == nil:", err == nil)
fmt.Printf("%v|%s|%q\n", err, err, err)
fmt.Println(err.Error())
1
2
3
4
5
6
7
8
9
10
$ go run .
err == nil: true
<nil>|%!s(<nil>)|%!q(<nil>)
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x0 pc=0x7ff7ed1e6daa]

goroutine 1 [running]:
main.main()
F:/Work/AI/Blog/_local/golab/h8/g1nil/main.go:9 +0xca
exit status 2

前两行还好,第三行直接崩,因为 nil 接口身上没有方法可以调,它是个空盒子,Error() 不在里面。%s 拿不到字符串也只是打一个占位符,不会停,所以真正危险的不是那些感叹号,是崩溃。判空只能用 == nil 或者 != nil 这种直接比,不能先调一下再看看,这一行写得对不对,区别是崩溃在源头,还是崩溃在两百行之外的另一个包里。

空盒子上调不到方法,判空只能拿它跟 nil 比。

不接这个返回值会怎样

不接这个返回值,没人会拦你。

把 os.Open 的返回值整个丢掉,编译能过,go vet 一声不吭,程序退出码还是 0。文件没打开,错误消失了,后面拿着一个空的句柄往下读,崩在别处,栈里跟源头一点关系都没有。这是 Go 里最典型的一种事故,它不报警,只是把问题往后推,推到你看不出因果的地方。

go vet 有个检查项专门管没被使用的返回值,但它只认一份写死的名单。同一份代码里,把 errors.New 的返回值丢掉它就会报。

1
2
3
errors.New("没人接")
fmt.Errorf("没人接: %w", errors.New("x"))
fmt.Sprintf("也没人接 %d", 1)
1
2
3
4
$ go vet ./...
main.go:9:2: result of errors.New call not used
main.go:10:2: result of fmt.Errorf call not used
main.go:11:2: result of fmt.Sprintf call not used

名单上有 errors.New、fmt.Errorf、fmt.Sprintf,os.Open 不在上面,所以同一个动作换个函数就没人管了。这套检查覆盖得并不全,社区才有 errcheck 这类外部工具补位。接了返回值但不使用是另一档,那归编译器管,直接编不过。

1
2
3
$ go build
# e5vet3
.\main.go:6:5: declared and not used: err

三档反应摆在一起,就是 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
2
3
base := errors.New("something failed")
wrapW := fmt.Errorf("wrap: %w", base)
wrapV := fmt.Errorf("wrap: %v", base)
1
2
3
4
5
6
7
8
$ go run .
--- 两句文本 ---
wrap: something failed
wrap: something failed
文本相等: true
--- 类型 ---
*fmt.wrapError
*errors.errorString

一个字都不差,类型不一样。%w 造出来的 *fmt.wrapError 身上多一个字段,专门存着内层那个错误,还实现了 Unwrap,把存着的东西原样还回去。%v 造出来的就是个普通字符串错误,内层已经被拼成文字了。区别要拿判断才能看出来。

1
2
3
4
fmt.Println("errors.Is(wrapW, base) =", errors.Is(wrapW, base))
fmt.Println("errors.Is(wrapV, base) =", errors.Is(wrapV, base))
fmt.Println("errors.Unwrap(wrapW) =", errors.Unwrap(wrapW))
fmt.Println("errors.Unwrap(wrapV) =", errors.Unwrap(wrapV))
1
2
3
4
errors.Is(wrapW, base) = true
errors.Is(wrapV, base) = false
errors.Unwrap(wrapW) = something failed
errors.Unwrap(wrapV) = <nil>

同一段逻辑只改一个字母,结论就翻过来。%w 那一版能顺着链摸回最里面那个值,%v 那一版摸不回去,Unwrap 给它一个 nil,说明这一层底下已经没东西了。这是本篇最要紧的一次对照,记住的不是哪个动词高级,而是包错的时候你以后还想不想判断这个错是什么。判断错是哪一种、想取出某个自定义类型,都得靠这条链还在,链断了,只剩一句拼好的文本,谁也认不出里面原本装的是什么。反过来有一种情况确实该用 %v,那就是这一层的库不想让调用方依赖内层的具体值,只想递出一句人能读懂的话,那就干脆不留链,把内层降成纯文本,别人也就没法拿 errors.Is 去问里面是什么。所以选动词的时候问自己的不是哪个更高级,而是外面那一层还有没有机会追问里面。

错误一层层往上返,Is 和 As 一层层往下钻

链长了两层之后,errors.Unwrap 一次只剥一层,剥到第三次拿到 nil,说明到底了。

1
2
3
4
5
l1 := fmt.Errorf("write %s: %w", "a.log", base)
l2 := fmt.Errorf("save: %w", l1)
fmt.Println(l2)
fmt.Println("第一层:", errors.Unwrap(l2))
fmt.Println("第二层:", errors.Unwrap(errors.Unwrap(l2)))
1
2
3
4
$ go run .
save: write a.log: disk full
第一层: write a.log: disk full
第二层: disk full

fmt.Println 打出来的是最外面那句话,中间那几层已经拼进文字里,所以看上去是一整句。想看清楚结构,换 %+v 也没用,它跟 %v 打出来的东西一模一样,Go 的错误没有那种把整条链展开的格式化动词。要看结构只能自己一层层 Unwrap,或者交给 errors.Is、errors.As 去问。

1
2
3
4
5
$ go run .
--- Println ---
save: write a.log: disk full
--- %+v ---
save: write a.log: disk full

两个错误同时发生、两个都得报的时候,用 errors.Join 把它们合成一个,判断对两边都成立。

1
2
3
4
5
6
e1 := errors.New("读配置失败")
e2 := errors.New("连数据库失败")
j := errors.Join(e1, e2)
fmt.Println(j)
fmt.Println("Is(e1) =", errors.Is(j, e1))
fmt.Println("Is(e2) =", errors.Is(j, e2))
1
2
3
4
5
6
7
$ go run .
读配置失败
连数据库失败
---
Is(e1) = true
Is(e2) = true
Unwrap() 里有 2 个

壳能一层层剥下去,拼成文字的那部分再也剥不回来。

自己的错误类型,用 As 取回来

有些错误要带字段。比如查不到用户,你要把状态码和那句人话一起带出去,定义一个结构体,给它挂一个 Error() string 方法,它就算一个错误类型了。

1
2
3
4
5
6
7
8
type MyError struct {
Code int
Msg string
}

func (e *MyError) Error() string {
return fmt.Sprintf("[%d] %s", e.Code, e.Msg)
}

方法接收者写的是 *MyError,所以只有指针满足 error,值不行,我第一版返回的是 MyError{...},编译器当场拦下来。

1
2
3
$ go run .
# g2ptr
.\main.go:15:9: cannot use MyError{…} (value of struct type MyError) as error value in return statement: MyError does not implement error (method Error has pointer receiver)

包了一层之后,想知道里面是不是这个类型,用 errors.As 取回来。第二个参数传一个指向目标类型的指针,找到就把值写进去,找不到就返回假,那个指针还是 nil。As 会顺着 Unwrap 一路往下找,外面裹了几层都不影响。

1
2
3
4
5
6
err := fmt.Errorf("加载用户页失败: %w", query())

var me *MyError
ok := errors.As(err, &me)
fmt.Println("errors.As =", ok)
fmt.Println("me.Code =", me.Code)
1
2
3
4
$ go run .
加载用户页失败: [404] user not found
errors.As = true
me.Code = 404

panic 不是错误的另一条路

panic 一按下去,程序立刻停。

它先把栈打出来,从崩的那一行一层层往上,每行都带着文件路径和行号。

1
2
3
func main() {
panic("boom")
}
1
2
3
4
5
6
7
$ go run .
panic: boom

goroutine 1 [running]:
main.main()
F:/Work/AI/Blog/_local/golab/h8/e10plain/main.go:4 +0x25
exit status 2

想接住它得靠 defer 加 recover,recover() 的返回值就是你 panic 时递进去的那个东西,类型都还在。

1
2
3
4
5
6
defer func() {
r := recover()
fmt.Println("recover 拿到:", r)
fmt.Printf("%T\n", r)
}()
panic("boom")
1
2
3
$ go run .
recover 拿到: boom
string

接住之后程序还能往下跑,但崩的那一行已经回不去了,栈也断了,所以它只适合兜底,不适合当控制流。拿它当分支用,读代码的人会以为这里真的出了要命的错。

判断一个错误该不该 panic,问一句上层有没有办法处理它就行,能处理就返回 error,处理不了才让它炸。

平时打日志用 log.Printf,它替你加上时间戳,%v 会去调那个错误的 Error(),包过的整条链的文字都在里面。

1
2
3
err := errors.New("连接被拒绝")
log.Printf("启动失败: %v", err)
log.Printf("启动失败: %v", fmt.Errorf("起服务: %w", err))
1
2
3
$ go run .
11:45:24 启动失败: 连接被拒绝
11:45:24 启动失败: 起服务: 连接被拒绝

log.Fatal 打完就调 os.Exit,注册过的 defer 一个都不会跑。

1
2
3
$ go run .
配置读不出来
exit status 1

这篇讲的东西都不难,难的是把它们连成一条习惯:函数末尾返回错误,中间每层想加信息就用 %w 包一次,调用方在每一层都判一次空,判到就往上走一层,在某个地方打一行日志。整条链上,错误值一直在,位置也一直清楚。

下一篇讲包和模块,一个项目怎么分目录、import 后面那串路径到底指到哪。