Go 博客

Go 1.13 中的错误处理

Damien Neil 和 Jonathan Amsterdam
2019 年 10 月 17 日

引言

Go 将错误视为值的处理方式在过去十年中为我们提供了很好的服务。尽管标准库对错误的支持很少——只有 errors.New 和 fmt.Errorf 函数，它们产生的错误只包含一条消息——但内置的 error 接口允许 Go 程序员添加他们想要的任何信息。它只需要一个实现了 Error 方法的类型。

type QueryError struct {
    Query string
    Err   error
}

func (e *QueryError) Error() string { return e.Query + ": " + e.Err.Error() }

这样的错误类型随处可见，它们存储的信息也千差万别，从时间戳到文件名再到服务器地址。通常，这些信息包含另一个较低级别的错误，以提供额外的上下文。

一个错误包含另一个错误的模式在 Go 代码中非常普遍，经过广泛讨论后，Go 1.13 添加了对此的显式支持。本文将描述标准库中提供此支持的新增内容：errors 包中的三个新函数，以及 fmt.Errorf 的一个新的格式化动词。

在详细描述这些变更之前，让我们回顾一下在之前的语言版本中如何检查和构造错误。

Go 1.13 之前的错误

检查错误

Go 错误是值。程序以几种方式根据这些值做出决定。最常见的方式是将错误与 nil 进行比较，以查看操作是否失败。

if err != nil {
    // something went wrong
}

有时我们将错误与一个已知的哨兵值进行比较，以查看是否发生了特定错误。

var ErrNotFound = errors.New("not found")

if err == ErrNotFound {
    // something wasn't found
}

错误值可以是满足语言定义的 error 接口的任何类型。程序可以使用类型断言或类型 switch 将错误值视为更具体的类型。

type NotFoundError struct {
    Name string
}

func (e *NotFoundError) Error() string { return e.Name + ": not found" }

if e, ok := err.(*NotFoundError); ok {
    // e.Name wasn't found
}

添加信息

函数经常在向上层调用堆栈传递错误时向其中添加信息，例如对错误发生时的简要描述。一种简单的方法是构造一个包含先前错误文本的新错误。

if err != nil {
    return fmt.Errorf("decompress %v: %v", name, err)
}

使用 fmt.Errorf 创建新错误会丢弃原始错误中的所有内容，只保留文本。正如我们在上面的 QueryError 中所见，有时我们可能希望定义一个包含底层错误的新错误类型，以便代码可以检查它。以下是 QueryError 的再次出现：

type QueryError struct {
    Query string
    Err   error
}

程序可以查看 *QueryError 值内部，以根据底层错误做出决策。有时你会看到这被称为“解包”错误。

if e, ok := err.(*QueryError); ok && e.Err == ErrPermission {
    // query failed because of a permission problem
}

标准库中的 os.PathError 类型是另一个包含其他错误的示例。

Go 1.13 中的错误

Unwrap 方法

Go 1.13 在 errors 和 fmt 标准库包中引入了新功能，以简化处理包含其他错误的错误。其中最重要的是一个约定而非改动：一个包含其他错误的错误可以实现一个 Unwrap 方法，返回底层错误。如果 e1.Unwrap() 返回 e2，那么我们称 e1 包装了 e2，并且你可以解包 e1 来获得 e2。

遵循此约定，我们可以为上面提到的 QueryError 类型提供一个 Unwrap 方法，返回其包含的错误。

func (e *QueryError) Unwrap() error { return e.Err }

解包错误的结果本身可能也有一个 Unwrap 方法；我们将重复解包产生的错误序列称为错误链。

使用 Is 和 As 检查错误

Go 1.13 的 errors 包包含两个用于检查错误的新函数：Is 和 As。

errors.Is 函数将错误与一个值进行比较。

// Similar to:
//   if err == ErrNotFound { … }
if errors.Is(err, ErrNotFound) {
    // something wasn't found
}

As 函数测试一个错误是否属于特定类型。

// Similar to:
//   if e, ok := err.(*QueryError); ok { … }
var e *QueryError
// Note: *QueryError is the type of the error.
if errors.As(err, &e) {
    // err is a *QueryError, and e is set to the error's value
}

在最简单的情况下，errors.Is 函数的行为类似于与哨兵错误进行比较，而 errors.As 函数的行为类似于类型断言。然而，当处理包装错误时，这些函数会考虑链中的所有错误。让我们再次查看上面解包 QueryError 以检查底层错误的示例：

if e, ok := err.(*QueryError); ok && e.Err == ErrPermission {
    // query failed because of a permission problem
}

使用 errors.Is 函数，我们可以这样写：

if errors.Is(err, ErrPermission) {
    // err, or some error that it wraps, is a permission problem
}

errors 包还包含一个新的 Unwrap 函数，它返回调用错误的 Unwrap 方法的结果，如果错误没有 Unwrap 方法则返回 nil。然而，通常最好使用 errors.Is 或 errors.As，因为这些函数会在一次调用中检查整个错误链。

注意：尽管获取指向指针的指针可能感觉奇怪，但在本例中是正确的。可以将其理解为获取错误类型值的指针；在本例中碰巧返回的错误是一个指针类型。

使用 %w 包装错误

如前所述，通常使用 fmt.Errorf 函数向错误添加额外信息。

if err != nil {
    return fmt.Errorf("decompress %v: %v", name, err)
}

在 Go 1.13 中，fmt.Errorf 函数支持一个新的 %w 动词。当存在此动词时，fmt.Errorf 返回的错误将具有一个 Unwrap 方法，返回 %w 的参数，该参数必须是一个错误。在所有其他方面，%w 与 %v 相同。

if err != nil {
    // Return an error which unwraps to err.
    return fmt.Errorf("decompress %v: %w", name, err)
}

使用 %w 包装错误使其可供 errors.Is 和 errors.As 使用。

err := fmt.Errorf("access denied: %w", ErrPermission)
...
if errors.Is(err, ErrPermission) ...

是否包装

在向错误添加额外上下文时，无论是使用 fmt.Errorf 还是通过实现自定义类型，都需要决定新错误是否应该包装原始错误。这个问题没有单一答案；它取决于创建新错误的上下文。包装错误是为了向调用者暴露它。如果包装错误会暴露实现细节，则不要包装。

举个例子，想象一个 Parse 函数，它从 io.Reader 中读取复杂的数据结构。如果发生错误，我们希望报告错误发生的行号和列号。如果在从 io.Reader 读取时发生错误，我们将希望包装该错误，以允许检查底层问题。由于调用者向函数提供了 io.Reader，暴露它产生的错误是有意义的。

相比之下，一个对数据库进行多次调用的函数可能不应该返回一个解包后是其中一次调用结果的错误。如果函数使用的数据库是实现细节，那么暴露这些错误就是违反抽象原则。例如，如果你的包 pkg 的 LookupUser 函数使用了 Go 的 database/sql 包，那么它可能会遇到 sql.ErrNoRows 错误。如果你使用 fmt.Errorf("accessing DB: %v", err) 返回该错误，那么调用者就无法查看内部以找到 sql.ErrNoRows。但如果函数返回的是 fmt.Errorf("accessing DB: %w", err)，那么调用者就可以合理地写：

err := pkg.LookupUser(...)
if errors.Is(err, sql.ErrNoRows) …

在这一点上，如果你不想破坏你的客户端，即使切换到不同的数据库包，该函数也必须始终返回 sql.ErrNoRows。换句话说，包装错误会使该错误成为你的 API 的一部分。如果你不想在将来承诺支持该错误作为 API 的一部分，就不应该包装该错误。

重要的是要记住，无论你是否包装，错误文本都是相同的。试图理解错误的人无论如何都会获得相同的信息；包装的选择在于是否向程序提供额外信息，以便它们能够做出更明智的决策，或者保留这些信息以维护抽象层。

使用 Is 和 As 方法自定义错误测试

errors.Is 函数检查链中的每个错误是否与目标值匹配。默认情况下，如果两者相等，则错误与目标匹配。此外，链中的错误可以通过实现 Is 方法来声明它与目标匹配。

例如，考虑这个受 Upspin error package 启发的错误，它将错误与模板进行比较，只考虑模板中非零的字段：

type Error struct {
    Path string
    User string
}

func (e *Error) Is(target error) bool {
    t, ok := target.(*Error)
    if !ok {
        return false
    }
    return (e.Path == t.Path || t.Path == "") &&
           (e.User == t.User || t.User == "")
}

if errors.Is(err, &Error{User: "someuser"}) {
    // err's User field is "someuser".
}

errors.As 函数在存在时也类似地参考 As 方法。

错误与包 API

返回错误的包（大多数都是如此）应该描述程序员可以依赖的那些错误的哪些属性。一个精心设计的包也应该避免返回不应该依赖的属性的错误。

最简单的规范是说明操作要么成功要么失败，分别返回 nil 或非 nil 错误值。在许多情况下，不需要更多信息。

如果我们希望一个函数返回一个可识别的错误条件，例如“未找到项目”，我们可以返回一个包装了哨兵错误的错误。

var ErrNotFound = errors.New("not found")

// FetchItem returns the named item.
//
// If no item with the name exists, FetchItem returns an error
// wrapping ErrNotFound.
func FetchItem(name string) (*Item, error) {
    if itemNotFound(name) {
        return nil, fmt.Errorf("%q: %w", name, ErrNotFound)
    }
    // ...
}

还有其他现有的模式可以提供可由调用者语义上检查的错误，例如直接返回哨兵值、特定类型或可以使用谓词函数检查的值。

在所有情况下，都应该注意不要向用户暴露内部细节。正如我们在上面的“是否包装”中提到的，当你从另一个包返回错误时，你应该将错误转换为不暴露底层错误的形式，除非你愿意承诺将来返回该特定错误。

f, err := os.Open(filename)
if err != nil {
    // The *os.PathError returned by os.Open is an internal detail.
    // To avoid exposing it to the caller, repackage it as a new
    // error with the same text. We use the %v formatting verb, since
    // %w would permit the caller to unwrap the original *os.PathError.
    return fmt.Errorf("%v", err)
}

如果一个函数被定义为返回一个包装了某个哨兵或类型的错误，请不要直接返回底层错误。

var ErrPermission = errors.New("permission denied")

// DoSomething returns an error wrapping ErrPermission if the user
// does not have permission to do something.
func DoSomething() error {
    if !userHasPermission() {
        // If we return ErrPermission directly, callers might come
        // to depend on the exact error value, writing code like this:
        //
        //     if err := pkg.DoSomething(); err == pkg.ErrPermission { … }
        //
        // This will cause problems if we want to add additional
        // context to the error in the future. To avoid this, we
        // return an error wrapping the sentinel so that users must
        // always unwrap it:
        //
        //     if err := pkg.DoSomething(); errors.Is(err, pkg.ErrPermission) { ... }
        return fmt.Errorf("%w", ErrPermission)
    }
    // ...
}

结论

尽管我们讨论的改动只有三个函数和一个格式化动词，但我们希望它们能极大地改善 Go 程序中错误的处理方式。我们期望通过包装来提供额外上下文将变得普遍，帮助程序做出更好的决策，并帮助程序员更快地找到 bug。

正如 Russ Cox 在他的 GopherCon 2019 主题演讲中所说，在迈向 Go 2 的道路上，我们进行实验、简化并发布。现在我们已经发布了这些改动，我们期待接下来的实验。