Go Error 嵌套到底是怎么实作的？-编程知识-白鹭情

原文链接： Go Error 嵌套到底是怎么实作的？

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 链中是否包含目标型别，这也就解决了上文提出的无法判断错误型别的问题，