错误类型

有很多种方法来声明 errors:

  • errors.New 声明简单的静态字符串错误信息
  • fmt.Errorf 声明格式化的字符串错误信息
  • 为自定义类型实现 Error() 方法
  • 通过 "pkg/errors".Wrap 包装错误类型

返回错误时，请考虑以下因素来作出最佳选择：

  • 这是一个不需要其他额外信息的简单错误吗？如果是，使用error.New。
  • 客户需要检测并处理此错误吗？如果是，那应该自定义类型，并实现 Error() 方法。
  • 是否是在传递一个下游函数返回的错误？如果是，请查看error 封装部分。
  • 其他，使用 fmt.Errorf 。

如果客户需要检测错误，并且是通过 errors.New 创建的一个简单的错误，请使用var 声明这个错误类型。

BadGood
  1. // package foo
  3. func Open() error {
  4.   return errors.New("could not open")
  5. }
  7. // package bar
  9. func use() {
  10.   if err := foo.Open(); err != nil {
  11.     if err.Error() == "could not open" {
  12.       // handle
  13.     } else {
  14.       panic("unknown error")
  15.     }
  16.   }
  17. }
 
  1. // package foo
  3. var ErrCouldNotOpen = errors.New("could not open")
  5. func Open() error {
  6.   return ErrCouldNotOpen
  7. }
  9. // package bar
  11. if err := foo.Open(); err != nil {
  12.   if err == foo.ErrCouldNotOpen {
  13.     // handle
  14.   } else {
  15.     panic("unknown error")
  16.   }
  17. }

如果你有一个错误需要客户端来检测，并且你想向其添加更多信息（例如，它不是一个简单的静态字符串），那么应该声明一个自定义类型。

BadGood
  1. func open(file string) error {
  2.   return fmt.Errorf("file %q not found", file)
  3. }
  5. func use() {
  6.   if err := open(); err != nil {
  7.     if strings.Contains(err.Error(), "not found") {
  8.       // handle
  9.     } else {
  10.       panic("unknown error")
  11.     }
  12.   }
  13. }
 
  1. type errNotFound struct {
  2.   file string
  3. }
  5. func (e errNotFound) Error() string {
  6.   return fmt.Sprintf("file %q not found", e.file)
  7. }
  9. func open(file string) error {
  10.   return errNotFound{file: file}
  11. }
  13. func use() {
  14.   if err := open(); err != nil {
  15.     if _, ok := err.(errNotFound); ok {
  16.       // handle
  17.     } else {
  18.       panic("unknown error")
  19.     }
  20.   }
  21. }

直接将自定义的错误类型设为导出需要特别小心，因为这意味着他们已经成为包的公开 API 的一部分了。更好的方式是暴露一个匹配函数来检测错误。

  1. // package foo
  3. type errNotFound struct {
  4.   file string
  5. }
  7. func (e errNotFound) Error() string {
  8.   return fmt.Sprintf("file %q not found", e.file)
  9. }
  11. func IsNotFoundError(err error) bool {
  12.   _, ok := err.(errNotFound)
  13.   return ok
  14. }
  16. func Open(file string) error {
  17.   return errNotFound{file: file}
  18. }
  20. // package bar
  22. if err := foo.Open("foo"); err != nil {
  23.   if foo.IsNotFoundError(err) {
  24.     // handle
  25.   } else {
  26.     panic("unknown error")
  27.   }
  28. }