• 错误类型

    错误类型

    有很多种方法来声明 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. }