err == Error 和 errors.Is(err, Error) 区别

热爱技术的小胡

已于 2023-12-04 16:21:19 修改

阅读量478

点赞数

文章标签： golang

于 2023-03-21 00:08:02 首次发布

本文链接：https://blog.csdn.net/NVG_Haru/article/details/129679445

版权

结论

err == Error 直接比较错误对象与指定的错误对象，也就是指针的对比。

errors.Is(err, Error) 通过不断解包err，如果匹配错误类型，则返回 true。

例子解读

var BaseErr = errors.New("the underlying base error")

func main() {
   err1 := fmt.Errorf("wrap base: %w", BaseErr)
   err2 := fmt.Errorf("wrap err1: %w", err1)
   println(err2 == BaseErr) // false
   if !errors.Is(err2, BaseErr) {
      panic("err2 is not BaseErr")
   }
   println("err2 is BaseErr")
}
/*
  打印结果：
  false
  err2 is BaseErr
*/

这段代码演示了如何使用fmt.Errorf对错误进行包装，并使用errors.Is进行错误匹配。

通过fmt.Errorf创建了一个名为BaseErr的错误。
将BaseErr包装在err1中，再将err1包装在err2中。
通过比较err2和BaseErr的相等性，发现它们不相等，因为err2经过了多次包装。
使用errors.Is判断err2是否包含BaseErr。由于err2包含了err1，而err1包含了BaseErr，所以err2也被认为包含了BaseErr。
打印出结果"err2 is BaseErr"，表示err2包含了BaseErr。

这说明errors.Is确确实实通过解包err2来判断是否属于BaseErr类型

源码解读

func Is(err, target error) bool {
   if target == nil {
      return err == target
   }

   isComparable := reflectlite.TypeOf(target).Comparable()
   for {
      if isComparable && err == target {
         return true
      }
      if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
         return true
      }
      if err = Unwrap(err); err == nil {
         return false
      }
   }
}

func Unwrap(err error) error {
  u, ok := err.(interface {
    Unwrap() error
  })
  if !ok {
    return nil
  }
  return u.Unwrap()
}

在 Is 函数中，如果这个 err 自己实现了 interface{ Is(error) bool } 接口，通过接口断言，可以调用 Is 方法判断 err 是否与 target 相等，否则递归调用 Unwrap 方法拆包装，返回下一层的 error 去判断是否与 target 相等。

拓展 errors.As

提取指定类型的错误，判断包装的 error 链中，某一个 error 的类型是否与 target 相同，并提取第一个符合目标类型的错误的值，将其赋值给 target。

type TypicalErr struct {
   e string
}

func (t TypicalErr) Error() string {
   return t.e
}

func main() {
   err := TypicalErr{"typical error"}
   err1 := fmt.Errorf("wrap err: %w", err)
   err2 := fmt.Errorf("wrap err1: %w", err1)
   var e TypicalErr
   if !errors.As(err2, &e) {
      panic("TypicalErr is not on the chain of err2")
   }
   println("TypicalErr is on the chain of err2")
   println(err == e)
}
/*
  打印结果：
  TypicalErr is on the chain of err2
  true
*/

来看一下 error.As 方法的源码：

func As(err error, target any) bool {
   if target == nil {
      panic("errors: target cannot be nil")
   }
   val := reflectlite.ValueOf(target)
   typ := val.Type()
   if typ.Kind() != reflectlite.Ptr || val.IsNil() {
      panic("errors: target must be a non-nil pointer")
   }
   targetType := typ.Elem()
   if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
      panic("errors: *target must be interface or implement error")
   }
   for err != nil {
      if reflectlite.TypeOf(err).AssignableTo(targetType) {
         val.Elem().Set(reflectlite.ValueOf(err))
         return true
      }
      if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) {
         return true
      }
      err = Unwrap(err)
   }
   return false
}

源码 for 循环前的部分是用来约束 target 参数的类型，要求其是一个非空的指针类型。此外要求 *target 是一个接口或者实现了 error 接口。

for 循环判断 err 是否可以赋值给 target 所属类型，如果可以则赋值返回 true。

如果 err 实现了自己的 As 方法，则调用其逻辑，否则也是走递归拆包的逻辑。

error 的定义

首先需要明确 Go 语言中的错误是通过接口定义的，因此是一个引用类型。

type error interface {
   Error() string
}
// Go 提供了一个默认实现
type errorString struct {
  s string
}

func (e *errorString) Error() string {
  return e.s
}

那么如果我要创建一个 error 实例，可以选择下面的方式：

func main() {
   // 此时创建的两个 error 都是 errorString 结构类型的
   errA := errors.New("new error a")
   fmt.Println(errA)
   errB := fmt.Errorf("new error %s", "b")
   fmt.Println(errB)
}
/*
  打印结果：
  new error a
  new error b
*/

wrapError 的定义

wrapError 是嵌套的 error ，也实现了 error 接口的 Error 方法，本质也是一个 error ，并声明了一个 Unwrap 方法用于拆包装。

type wrapError struct {
  msg string
  err error
}

func (e *wrapError) Error() string {
  return e.msg
}

func (e *wrapError) Unwrap() error {
  return e.err
}

通过 fmt.Errorf 方法配合 %w 占位符创建嵌套类型的 wrapError。

var BaseErr = errors.New("the underlying base error")

func main() {
  err1 := fmt.Errorf("wrap base: %w", BaseErr)
  fmt.Println(err1)
  err2 := fmt.Errorf("wrap err1: %w", err1)
  fmt.Println(err2)
}
/*
  打印结果：
  wrap base: the underlying base error
  wrap err1: wrap base: the underlying base error
*/

为什么 fmt.Errorf 用了占位符 %w 之后创建的就是 wrapError 类型，而用了 fmt.Errorf 但只是选择其他占位符如上述示例中的 %s 创建的就是 errorString 类型？

可以简单看一下 fmt.Errorf 方法的源码：

func Errorf(format string, a ...any) error {
   p := newPrinter()
   p.wrapErrs = true
   p.doPrintf(format, a)
   s := string(p.buf)
   var err error
   if p.wrappedErr == nil {
      err = errors.New(s)
   } else {
      err = &wrapError{s, p.wrappedErr}
   }
   p.free()
   return err
}

核心就是 p.doPrintf(format, a) 调用后，如果包含 %w 占位符则会先创建内层的 error ，赋值给 p.wrappedErr ，从而触发 wrapError 的创建逻辑。

你也可以进一步去看 p.doPrintf(format, a) 的实现印证这个流程。

errors.Is

判断被包装的error是否包含指定错误。

var BaseErr = errors.New("the underlying base error")

func main() {
   err1 := fmt.Errorf("wrap base: %w", BaseErr)
   err2 := fmt.Errorf("wrap err1: %w", err1)
   println(err2 == BaseErr) // false
   if !errors.Is(err2, BaseErr) {
      panic("err2 is not BaseErr")
   }
   println("err2 is BaseErr")
}
/*
  打印结果：
  false
  err2 is BaseErr
*/

来看一下 errors.Is 方法的源码：

func Is(err, target error) bool {
   if target == nil {
      return err == target
   }

   isComparable := reflectlite.TypeOf(target).Comparable()
   for {
      if isComparable && err == target {
         return true
      }
      if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
         return true
      }
      if err = Unwrap(err); err == nil {
         return false
      }
   }
}

func Unwrap(err error) error {
  u, ok := err.(interface {
    Unwrap() error
  })
  if !ok {
    return nil
  }
  return u.Unwrap()
}

如果这个 err 自己实现了 interface{ Is(error) bool } 接口，通过接口断言，可以调用 Is 方法判断 err 是否与 target 相等。

否则递归调用 Unwrap 方法拆包装，返回下一层的 error 去判断是否与 target 相等。

errors.As

提取指定类型的错误，判断包装的 error 链中，某一个 error 的类型是否与 target 相同，并提取第一个符合目标类型的错误的值，将其赋值给 target。

type TypicalErr struct {
   e string
}

func (t TypicalErr) Error() string {
   return t.e
}

func main() {
   err := TypicalErr{"typical error"}
   err1 := fmt.Errorf("wrap err: %w", err)
   err2 := fmt.Errorf("wrap err1: %w", err1)
   var e TypicalErr
   if !errors.As(err2, &e) {
      panic("TypicalErr is not on the chain of err2")
   }
   println("TypicalErr is on the chain of err2")
   println(err == e)
}
/*
  打印结果：
  TypicalErr is on the chain of err2
  true
*/

来看一下 error.As 方法的源码：

func As(err error, target any) bool {
   if target == nil {
      panic("errors: target cannot be nil")
   }
   val := reflectlite.ValueOf(target)
   typ := val.Type()
   if typ.Kind() != reflectlite.Ptr || val.IsNil() {
      panic("errors: target must be a non-nil pointer")
   }
   targetType := typ.Elem()
   if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
      panic("errors: *target must be interface or implement error")
   }
   for err != nil {
      if reflectlite.TypeOf(err).AssignableTo(targetType) {
         val.Elem().Set(reflectlite.ValueOf(err))
         return true
      }
      if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) {
         return true
      }
      err = Unwrap(err)
   }
   return false
}

源码 for 循环前的部分是用来约束 target 参数的类型，要求其是一个非空的指针类型。

此外要求 *target 是一个接口或者实现了 error 接口。

for 循环判断 err 是否可以赋值给 target 所属类型，如果可以则赋值返回 true。

如果 err 实现了自己的 As 方法，则调用其逻辑，否则也是走递归拆包的逻辑。

热爱技术的小胡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
err == Error 和 errors.Is(err, Error) 区别

err == Error 直接比较错误对象与指定的错误对象，也就是指针的对比。errors.Is(err, Error) 通过不断解包err，如果匹配错误类型，则返回 true。
复制链接

扫一扫