介绍

Golang 或 Go 具有强大的错误处理机制，该机制是语言设计中不可或缺的一部分。虽然 Go 提供了内置错误类型，但在某些情况下，您可能需要在错误处理中进行更多控制和上下文。
这就是创建自定义错误发挥作用的地方。自定义错误可以为您提供更多信息性错误消息，并可用于对应用程序中的不同类型的错误进行分类。

在本文中，我们将探讨如何在 Golang 中有效地创建和使用自定义错误。

了解 Go 的内置错误处理

在 Go 中，错误类型是一个内置接口，如下所示：

type error interface {
    Error() string
}

任何以字符串返回类型实现 Error() 方法的类型都满足此接口，并且可以被视为错误。这很简单但功能强大，因为它允许您通过简单地实现此方法来创建自定义错误类型。

Go 中的基本错误处理

这是 Go 中基本错误处理的快速示例：

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return errors.New("something went wrong")
}

此示例使用errors.New函数创建基本错误。虽然这对于简单的情况很有用，但它缺乏提供更多上下文或区分不同类型错误的能力。

为什么要创建自定义错误？

当您需要更多描述性错误消息或希望以不同方式处理不同类型的错误时，自定义错误至关重要。例如，您可能希望在未找到文件时返回特定的错误类型，在文件损坏时返回另一种类型。自定义错误还可以携带额外的数据，使调试更容易并向调用者提供更详细的信息。

在 Go 中创建自定义错误

要在 Go 中创建自定义错误，您需要定义一个实现 Error() 方法的新类型。让我们来看一个例子。

示例 1：一个简单的自定义错误

以下是创建简单的自定义错误的方法：

package main

import (
    "fmt"
)

type MyError struct {
    Code    int
    Message string
}

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

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return &MyError{
        Code:    404,
        Message: "Resource not found",
    }
}

在此示例中，MyError 是包含代码和消息的自定义错误类型。 Error() 方法将它们格式化为字符串，从而可以轻松打印或记录错误。

示例2：用errors.Is函数检查错误

有时，直接比较错误很有用。这就是哨兵错误出现的地方。哨兵错误是预定义的导出变量，代表特定错误。

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    err := doSomething()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return ErrNotFound
}

虽然这种方法很简单，但将哨兵值与自定义错误类型相结合可以更强大，允许进行错误比较和丰富的错误数据。

示例 3：包装错误以获取更多上下文

Go 1.13 引入了带有 %w 动词的 fmt.Errorf 函数，它允许您包装错误，在保留原始错误的同时添加更多上下文。

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return fmt.Errorf("failed to do something: %w", err)
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

这允许您检查特定错误并维护一堆错误，以提供有关出错原因的更多上下文。

示例 4：使用 Unwrap() 方法丰富错误

Go 还提供了一种使用 Unwrap() 方法提取包装错误的方法。通过在自定义错误类型中实现此方法，您可以允许进一步展开错误。

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

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

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

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

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

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

这里，MyError 有一个 Unwrap() 方法，它返回包装的错误。这允许更深入地检查和处理潜在的错误。

示例5：使用errors.As函数检查错误

Go还提供了一种用errors.As方法来提取错误的方法。通过在自定义错误类型中实现此方法，您可以检查错误类型并获取自定义错误值。

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s: %v", e.Code, e.Message, e.Err)
}

func main() {
    err := doSomething()
    var mErr *MyError
    // another way to initialize custom error
    // mErr := &MyError{}
    if errors.As(err, &mErr) {
        fmt.Println("Error:", mErr)
    }
}

// doSomething attempts to fetch a resource and returns an error if it fails.
// If the error is ErrNotFound, it is wrapped in a MyError with a code of 500.
func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

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

func fetchResource() error {
    return ErrNotFound
}

Go 中自定义错误的最佳实践

1. 谨慎使用自定义错误：自定义错误功能强大，但会增加复杂性。当它们提供显着的好处时使用它们，例如更好的错误分类或附加上下文。

2. 利用包装和展开： 使用附加上下文包装错误并稍后展开它们是增强错误调试的最佳实践。

3. 记录您的错误类型： 确保所有自定义错误都有详细记录，以便其目的和用法明确。

4. 首选使用错误值进行比较：当您需要比较错误时，请考虑使用预定义的错误值（哨兵错误）以保持一致性和清晰度。

结论

Go 中的自定义错误提供了一种灵活而强大的方法来管理应用程序中的错误。通过创建自己的错误类型、包装错误以获取更多上下文以及展开它们以进行更深入的检查，您可以构建强大且可维护的错误处理机制。这不仅有助于调试，还可以提高 Go 代码的整体质量。
选择有错误的策略并在整个项目中使用一致的错误。