Go Error 的设计哲学是 「Errors Are Values」。
这句话应该怎么理解呢?翻译起来挺难的。不过从源码的角度来看，好像更容易理解其背后的含义。
Go Error 源码很简单，寥寥几行：
- // src/builtin/builtin.go
- type error interface {
- Error() string
- }
error 是一个接口类型，只需要实现 Error() 方法即可。在 Error() 方法中，就可以返回自定义结构体的任意内容。
下面首先说说如何创建 error。
创建 Error
创建 error 有两种方式，分别是：
- errors.New();
- fmt.Errorf()。
errors.New()
errors.New() 的使用延续了 Go 的一贯风格，New 一下就可以了。
举一个例子：
- package main
- import (
- "errors"
- "fmt"
- )
- func main() {
- err := errors.New("这是 errors.New() 创建的错误")
- fmt.Printf("err 错误类型：%T，错误为：%v\n", err, err)
- }
- /* 输出
- err 错误类型：*errors.errorString，错误为：这是 errors.New() 创建的错误
- */
这段代码唯一让人困惑的地方可能就是错误类型了，但没关系。只要看一下源码，就瞬间迎刃而解。
源码如下：
- // src/errors/errors.go
- // New returns an error that formats as the given text.
- // Each call to New returns a distinct error value even if the text is identical.
- func New(text string) error {
- return &errorString{text}
- }
- // errorString is a trivial implementation of error.
- type errorString struct {
- s string
- }
- func (e *errorString) Error() string {
- return e.s
- }
可以看到，errorString 是一个结构体，实现了 Error() 方法，New 函数直接返回 errorString 指针。
这种用法很简单，但不实用。假如我还想返回程序的上下文信息，它就没辙了。
下面看第二种方式。
fmt.Errorf()
还是先看一个例子：
- package main
- import (
- "database/sql"
- "fmt"
- )
- func foo() error {
- return sql.ErrNoRows
- }
- func bar() error {
- return foo()
- }
- func main() {
- err := bar()
- if err == sql.ErrNoRows {
- fmt.Printf("data not found, %+v\n", err)
- return
- }
- if err != nil {
- fmt.Println("Unknown error")
- }
- }
- /* 输出
- data not found, sql: no rows in result set
- */
这个例子输出了我们想要的结果，但是还不够。
一般情况下，我们会通过使用 fmt.Errorf() 函数，附加上我们想添加的文本信息，使返回内容更明确，处理起来更灵活。
所以，foo() 函数会改成下面这样：
- func foo() error {
- return fmt.Errorf("foo err, %v", sql.ErrNoRows)
- }
这时问题就出现了，经过 fmt.Errorf() 的封装，原始 error 类型发生了改变，这就导致 err == sql.ErrNoRows 不再成立，返回信息变成了 Unknown error。
如果想根据返回的 error 类型做不同处理，就无法实现了。
因此，Go 1.13 为我们提供了 wrapError 来处理这个问题。
Wrap Error
看一个例子：
- package main
- import (
- "fmt"
- )
- type myError struct{}
- func (e myError) Error() string {
- return "Error happended"
- }
- func main() {
- e1 := myError{}
- e2 := fmt.Errorf("E2: %w", e1)
- e3 := fmt.Errorf("E3: %w", e2)
- fmt.Println(e2)
- fmt.Println(e3)
- }
- /* output
- E2: Error happended
- E3: E2: Error happended
- */
乍一看好像好没什么区别，但背后的实现原理却并不相同。
Go 扩展了 fmt.Errorf() 函数，增加了一个 %w 标识符来创建 wrapError。
- // src/fmt/errors.go
- func Errorf(format string, a ...interface{}) error {
- p := newPrinter()
- p.wrapErrs = true
- p.doPrintf(format, a)
- s := string(p.buf)
- var err error
- if p.wrappedErr == nil {
- err = errors.New(s)
- } else {
- err = &wrapError{s, p.wrappedErr}
- }
- p.free()
- return err
- }
当使用 w% 时，函数会返回 &wrapError{s, p.wrappedErr}，wrapError 结构体定义如下：
- // src/fmt/errors.go
- type wrapError struct {
- msg string
- err error
- }
- func (e *wrapError) Error() string {
- return e.msg
- }
- func (e *wrapError) Unwrap() error {
- return e.err
- }
实现了 Error() 方法，说明它是一个 error，而 Unwrap() 方法是为了获取被封装的 error。
- // src/errors/wrap.go
- func Unwrap(err error) error {
- u, ok := err.(interface {
- Unwrap() error
- })
- if !ok {
- return nil
- }
- return u.Unwrap()
- }
它们之间的关系是这样的：
因此，我们可以使用 w% 将上文中的程序进行改造，使其内容输出更丰富。
如下：
- package main
- import (
- "database/sql"
- "errors"
- "fmt"
- )
- func bar() error {
- if err := foo(); err != nil {
- return fmt.Errorf("bar failed: %w", foo())
- }
- return nil
- }
- func foo() error {
- return fmt.Errorf("foo failed: %w", sql.ErrNoRows)
- }
- func main() {
- err := bar()
- if errors.Is(err, sql.ErrNoRows) {
- fmt.Printf("data not found, %+v\n", err)
- return
- }
- if err != nil {
- fmt.Println("Unknown error")
- }
- }
- /* output
- data not found, bar failed: foo failed: sql: no rows in result set
- */
终于有了让人满意的输出结果，每个函数都增加了必要的上下文信息，而且也符合对错误类型的判断。
errors.Is() 函数用来判断 err 以及其封装的 error 链中是否包含目标类型。这也就解决了上文提出的无法判断错误类型的问题。
后记
其实，Go 目前对 Error 的处理方式也是充满争议的。不过，官方团队正在积极和社区交流，提出改进方法。相信在不久的将来，一定会找到更好的解决方案。
现阶段来说，大部分团队可能会选择 github.com/pkg/errors 包来进行错误处理。如果感兴趣的话，可以学学看。
原文链接：https://mp.weixin.qq.com/s/nWb-0RTDG1Pg5ZmJZfbEPA
