在 Go 中创建自定义错误

介绍

GO 标准库提供了errors.Newandfmt.Errorf 这两种方法来在创建错误。但是这两种方法并不能满足你的用户或者后期调试时提供更加复杂的错误信息或者报告发生了什么。为了传递这种更复杂的错误信息并获得更多功能，我们可以实现标准库 error 接口类型。

error 接口定义如下：

  1. type error interface {
  2.   Error() string
  3. }

内置 软件包将 error 定义为具有单个 Error() 方法的接口，该接口将错误消息字符串作为返回。通过实现此方法，我们可以将定义的任何类型转换为自己的错误。

让我们尝试运行以下示例以查看 error 接口的实现：

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. // 定义一个 MyError 的接口体
  9. type MyError struct{}
  11. // 实现 error 接口的 Error 方法
  12. func (m *MyError) Error() string {
  13.     return "boom"
  14. }
  16. // 定义 sayHello 函数
  17. // 函数返回类型为 string 和 error
  18. func sayHello() (string, error) {
  19.     // 由于 *MyError 实现了 error 接口
  20.     // 所以 &MyError{} 可以作为 error 对象返回
  21.     return "", &MyError{}
  22. }
  24. func main() {
  25.     s, err := sayHello()
  26.     if err != nil {
  27.         fmt.Println("unexpected error: err:", err)
  28.         os.Exit(1)
  29.     }
  30.     fmt.Println("The string:", s)
  31. }

我们将看到以下输出：

  1. # Output
  2. unexpected error: err: boom
  3. exit status 1

在这里，我们创建了一个新的空结构类型 MyError，并在其上定义了 Error() 方法。Error() 方法返回字符串 "Boom"。

在 main() 中，我们调用 sayhello 函数，该函数返回一个空字符串和一个新 MyError 实例。由于 sayhello 将始终返回错误，因此在main() 中的 if 语句主体内的 fmt.Println 调用将始终执行。我们使用 fmt.Println 来打印短前缀字符串 "unexpected error:"以及在保存MyError 实例中的在 err 变量。

值得注意的是，我们不必直接调用 Error()，因为 fmt 包能够自动检测到已经实现了 error 接口。它 透明>) 地调用 Error() 来获取字符串 "hoom"，并将其与前缀字符串 "unexpected error: err:" 相连。

自定义错误收集详细信息

有时，自定义错误是捕获详细错误信息的最有效的方式。例如，假设我们要捕获 HTTP 请求产生的错误的状态代码；运行以下程序以查看 error 的实现，使我们能够清晰捕获该信息：

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "os"
  7. )
  9. type RequestError struct {
  10.     StatusCode int
  12.     Err error
  13. }
  15. func (r *RequestError) Error() string {
  16.     return fmt.Sprintf("status %d: err %v", r.StatusCode, r.Err)
  17. }
  19. func doRequest() error {
  20.     return &RequestError{
  21.         StatusCode: 503,
  22.         Err:        errors.New("unavailable"),
  23.     }
  24. }
  26. func main() {
  27.     err := doRequest()
  28.     if err != nil {
  29.         fmt.Println(err)
  30.         os.Exit(1)
  31.     }
  32.     fmt.Println("success!")
  33. }

我们将看到以下输出：

  1. # Output
  2. status 503: err unavailable
  3. exit status 1

在此示例中，我们创建了创建一个错误的 RequestError 的新实例, 其中包含一个状态码和使用标准库提供的 errors.New 函数创建的 err。之后，如前所述，我们使用 fmt.Println 打印了错误信息。

在 RequestError 的 Error() 方法中，我们使用创建 error 对象时提供的信息和 fmt.Sprintf 函数构造字符串。

类型断言和自定义错误

error 接口仅公开一种方法，但是为了正确处理错误, 我们可能需要访问 error 实现类型的其他方法。例如，我们可能有几个暂时的自定义错误实现，可以通过 Temporary() 方法的存在来重述。

接口为类型提供的更广泛的方法集提中供了一个狭窄的视图，因此，我们必须使用类型断言来更改视图正在显示的方法，或完全删除它。

下面的示例增加了前面显示的 RequestError 具有 Temporary() 方法，该方法将指示调用者是否应重试请求：

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "net/http"
  7.     "os"
  8. )
  10. type RequestError struct {
  11.     StatusCode int
  13.     Err error
  14. }
  16. func (r *RequestError) Error() string {
  17.     return r.Err.Error()
  18. }
  20. func (r *RequestError) Temporary() bool {
  21.     // 如果状态码是 503 返回 true
  22.     return r.StatusCode == http.StatusServiceUnavailable // 503
  23. }
  25. func doRequest() error {
  26.     return &RequestError{
  27.         StatusCode: 503,
  28.         Err:        errors.New("unavailable"),
  29.     }
  30. }
  32. func main() {
  33.     err := doRequest()
  34.     if err != nil {
  35.         fmt.Println(err)
  36.         // 进行类型断言
  37.         re, ok := err.(*RequestError)
  38.         // 如果类型断言成功
  39.         if ok {
  41.             if re.Temporary() {
  42.                 fmt.Println("This request can be tried again")
  43.             } else {
  44.                 fmt.Println("This request cannot be tried again")
  45.             }
  46.         }
  47.         os.Exit(1)
  48.     }
  50.     fmt.Println("success!")
  51. }

我们将看到以下输出：

  1. # Output
  2. unavailable
  3. This request can be tried again
  4. exit status 1

在 main() 中，我们调用 doRequest() 将错误接口返回给我们。我们首先打印由 Error() 方法返回的错误消息。接下来，我们尝试通过使用类型的断言 re, ok := err.(*RequestError)。如果类型断言成功，我们然后使用 Temporary() 方法来查看此错误是否是临时错误。由于doRequest() 设置的状态代码为 503，它匹配 HTTP.Statusserviceunavailable，因此将返回 true，并且要打印"This request can be tried again" 的原因。实际上，我们将提出另一个请求，而不是打印消息。

包装错误

通常，错误是从程序的外部产生(例如：数据库，网络连接等)。这些错误提供的错误消息不能够帮助任何人找到错误的根源。有必要在错误消息开始时，将错误与额外信息包装，将为成功调试提供一些必要的上下文。

下面的示例说明了我们如何将一些上下文信息附加到从其他功能中返回的其他隐性错误：

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6. )
  8. // 定义一个错误的包装类型
  9. type WrappedError struct {
  10.     // 上下文信息
  11.     Context string
  12.     // 具体错误内容
  13.     Err     error
  14. }
  16. func (w *WrappedError) Error() string {
  17.     return fmt.Sprintf("%s: %v", w.Context, w.Err)
  18. }
  20. func Wrap(err error, info string) *WrappedError {
  21.     return &WrappedError{
  22.         Context: info,
  23.         Err:     err,
  24.     }
  25. }
  27. func main() {
  28.     err := errors.New("boom!")
  29.     err = Wrap(err, "main")
  31.     fmt.Println(err)
  32. }

我们将看到以下输出

  1. # Output
  2. main: boom!

WrappedError 是一个具有两个字段的结构：字符串类型的 context 字段和 error, 这让 WrappedError 提供了更多信息。当调用 Error() 方法时，我们再次使用 fmt.Sprintf 打印上下文消息和 error(fmt.Sprintf 也会隐式调用 err 的 Error() 方法)。

在 main() 中，我们使用 errors.New 创建一个错误，然后我们使用定义的 Wrap 函数包装该错误。这使我们可以指出此错误是在 "main" 中生成的。另外，由于我们的 WrappedError 也是一个 error，因此我们也可以包装其它的WrappedError - 这将使我们看到链条来帮助我们追踪错误源。在标准库的一点帮助下，我们甚至可以在错误中嵌入完整的堆栈跟踪。

总结

由于 error 接口只提供一种方法，我们已经看到，在为不同情况提供不同类型的错误方面，我们有很大的灵活性。这可以包含所有内容，从传达多个信息作为错误的一部分到实现 指数退回。尽管表面上的错误处理机制似乎很简单，但我们可以使用这些自定义错误来处理常见和不常见情况。

GO 有另一种传达意外行为的机制，panic。在错误处理系列的下一篇文章中，我们将检查恐慌 - 它们是什么以及如何处理它们。