官方库

wrap错误

  1. e := errors.New("原始错误e")
  2. w := fmt.Errorf("Wrap了一个错误%w", e)

unwrap

  1. func Unwrap(err error) error

Is

  1. func Is(err, target error) bool
  1. 如果err和target是同一个，那么返回true
  2. target包含在这个嵌套error链中的话，那么也返回true。

源代码

  1. func Is(err, target error) bool {
  2.     if target == nil {
  3.         return err == target
  4.     }
  6.     isComparable := reflectlite.TypeOf(target).Comparable()
  8.     //for循环，把err一层层剥开，一个个比较，找到就返回true
  9.     for {
  10.         if isComparable && err == target {
  11.             return true
  12.         }
  13.         //这里意味着你可以自定义error的Is方法，实现自己的比较代码
  14.         if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
  15.             return true
  16.         }
  17.         //剥开一层，返回被嵌套的err
  18.         if err = Unwrap(err); err == nil {
  19.             return false
  20.         }
  21.     }
  22. }

As

  1. // 以前的做法：
  2. if perr, ok := err.(*os.PathError); ok {
  3.     fmt.Println(perr.Path)
  4. }
  6. // 使用As
  7. var perr *os.PathError
  8. if errors.As(err, &perr) {
  9.     fmt.Println(perr.Path)
  10. }

As所做的就是遍历err嵌套链，从里面找到类型符合的error，然后把这个error赋予target,这样我们就可以使用转换后的target了，这里有值得赋予，所以target必须是一个指针。

源代码

  1. func As(err error, target interface{}) bool {
  2.     //一些判断，保证target，这里是不能为nil
  3.     if target == nil {
  4.         panic("errors: target cannot be nil")
  5.     }
  6.     val := reflectlite.ValueOf(target)
  7.     typ := val.Type()
  9.     //这里确保target必须是一个非nil指针
  10.     if typ.Kind() != reflectlite.Ptr || val.IsNil() {
  11.         panic("errors: target must be a non-nil pointer")
  12.     }
  14.     //这里确保target是一个接口或者实现了error接口
  15.     if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {
  16.         panic("errors: *target must be interface or implement error")
  17.     }
  18.     targetType := typ.Elem()
  19.     for err != nil {
  20.         //关键部分，反射判断是否可被赋予，如果可以就赋值并且返回true
  21.         //本质上，就是类型断言，这是反射的写法
  22.         if reflectlite.TypeOf(err).AssignableTo(targetType) {
  23.             val.Elem().Set(reflectlite.ValueOf(err))
  24.             return true
  25.         }
  26.         //这里意味着你可以自定义error的As方法，实现自己的类型断言代码
  27.         if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
  28.             return true
  29.         }
  30.         //这里是遍历error链的关键，不停的Unwrap，一层层的获取err
  31.         err = Unwrap(err)
  32.     }
  33.     return false
  34. }

第三方库

“github.com/pkg/errors”

errors.New(“这是起点”)

生成一个新的错误，该错误包含了堆栈信息及文字信息（标准库中errors的err只有文字信息）

errors.Wrap(err, “第二站”)

为err附加堆栈信息及文字信息（最好不要重复附加堆栈信息）

errors.WithMessage(err, “第二站”)

只附加文字信息

errors.WithStack(err)

只附加堆栈信息

errors.Unwrap(err)

去掉最外一层的err信息

errors.Cause(err)

获取err起始错误信息

fmt.Printf(“%+v\n”, err)

打印全部错误信息