golang 错误处理

// 工厂方法，创建错误
// 可以推断 error 是一个接口:
//
// type error interface {
//     Error() string
// }
//
func New(text string) error {
  return errorString{text}
}


// errorString 结构体实现了 error 接口
type errorString struct {
  s string
}


// 该结构体只有一个方法，返回错误字符串
func (e *errorString) Error() string {
  return e.s
}

var (
  AssertError = errors.New("assert error")
)


// 直接返回错误
func f() error {
  return AssertError
}


// c() 调用 f()
func c() error {
  // golang 一般错误处理方式
  err := f()
  if err != nil {
    return err
  }


  fmt.Println("do somthing")
  return nil
}


func main() {
  err := c()
  if err != nil {
    fmt.Printf("main invoke c(): %+v\n", err)
  }
}

main invoke c(): assert error

func f() error {
  return AssertError
}


func c() error {


  err := f()
  if err != nil {
    // 错误中添加上下文信息
    return fmt.Errorf("c invoke f err, %v", err)
  }


  fmt.Println("do somthing")
  return nil
}


func main() {
  err := c()


  // 如果是 AssertError，则一种处理方式
  // 其它错误走额外的分支
  if err == AssertError {
    fmt.Println("main invoke c(): AssertError\n")
  } else {
    fmt.Printf("unknown err: %+v\n", err)
  }
}

unknown err: c invoke f err, assert error

func f() error {
  // Wrap 在 error 基础上添加调用栈信息，同时添加额外的
  // 用户上下文信息，如果err是nil，则返回的是nil
  return pkgerr.Wrap(AssertError, "inner f err")


  // WithStack 只添加调用栈信息
  //return pkgerr.WithStack(AssertError)
}


func c() error {


  err := f()
  if err != nil {
    // WithMessage 仅仅添加上下文信息
    return pkgerr.WithMessage(err, "c invoke f")
  }


  fmt.Println("do somthing")
  return nil
}


func main() {
  err := c()
  if err != AssertError {
    fmt.Printf("main invoke c()--------------------->: %+v\n", err)
  }
}

main invoke c()--------------------->: assert error
inner f err
main.f
  Users/dkos/t/newquick.go:17
main.c
  Users/dkos/t/newquick.go:25
main.main
  Users/dkos/t/newquick.go:36
runtime.main
  usr/local/go/src/runtime/proc.go:225
runtime.goexit
  usr/local/go/src/runtime/asm_amd64.s:1371
c invoke f

func Wrap(err error, message string) error {
  // 本身没有错误的话，直接返回 nil
  if err == nil {
    return nil
  }
  
  // withMessage 实现了 error 接口
  // 同时提供了其它功能
  //
  // cause: 存储错误
  // msg： 用户要添加的上下文信息
  err = &withMessage{
    cause: err,
    msg:   message,
  }
  
  // withStack 继承了（嵌入了） error，
  // 同时调用底层 runtime.Callers 读取
  // 调用栈信息
   return &withStack{
    err,
    callers(),
  }
}

func WithMessage(err error, message string) error {
  // 本身没有错误的话，直接返回 nil
  if err == nil {
    return nil
  }
  
  // 这里如果 err 被 wrap 的话，那么本身就含有栈信息
  // 若是 err 没有 Wrap 过，直接添加上下文信息返回
  return &withMessage{
    cause: err,
    msg:   message,
  }
}

func Cause(err error) error {
  type causer interface {
    Cause() error
  }


  for err != nil {
    // 判断 err 有无实现 cause 接口
    // 如果本身没有实现，则 err 本身
    // 就是触发错误的原始错误
    cause, ok := err.(causer)
    if !ok {
      break
    }
    // 如果 err 实现了 cause 接口，
    // 那么说明它还有底层错误，此时
    // 循环查询错误链，直到查到没有
    // 实现 causer 接口的错误，该
    // 错误就是为经过加工的最原始错误
    err = cause.Cause()
  }
  
  // 返回原始错误
  return err
}

func Is(err, target error) bool {
  // 可以判断错误是否为 nil
  if target == nil {
    return err == target
  }


  // 检查 error 是否为可比类型
  isComparable := reflectlite.TypeOf(target).Comparable()
  for {
    // 可比时，判定是否w诶目标，是则直接返回
    if isComparable && err == target {
      return true
    }
    
    // 判断是否实现 Is 接口，若实现了，则直接可以用
    // Is 接口判定，但是对于这里的 github.com/pkg/errors
    // 提供的几个结构都没有实现该接口
    if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
      return true
    }
    
    // 若是没有实现 Is 接口，则调用 Unwrap，它会调用
    // 实际实现 error 接口的类型的 Unwrap 拿到底层错误
    // 实际取的就是 cause 存储的 error，Unrap 也是一个
    // 拆错误链的过程，边拆边比较看是否和目标相同
    if err = Unwrap(err); err == nil {
      return false
    }
  }
}