go1.13中引入err wraping机制
1.13前函数返回一个error errors.New()创建一个errorString
errorString 只包含了一个字符串 实现了error接口的Error方法
当函数嵌套返回时 嵌套层数更深的error只保留了字符串信息 丢失了原始的类型

// Each call to New returns a distinct error value even if the text is identical.
func New(text string) error {
    return &errorString{text}
}

// errorString is a trivial implementation of error.
type errorString struct {
    s string
}

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

// test
func f1() error {
    return errors.New("e1")
}

func f2() error {
    e1 := f1()
    return fmt.Errorf("e2 %s", e1)
}

func main() {
    fmt.Println(f2())
}

>>> e2 e1

err wraping %w Unwrap Is As

    func main() {
    err := errors.New("raw err")
        // fmt.Errorf中的%w占位符可以wrap一个err 可以重复wrap
    errw := fmt.Errorf("wrapped err %w", err)
        // 用于比较一个err是否是target类型的error 
    fmt.Println(errors.Is(errw, err))
        // 取出被wrap的error 可以重复调用取出多层
    fmt.Println(errors.Unwrap(errw))
}

As 函数可以用来断言一个error的类型

  func main() {
    var err error
    err = &os.PathError{
        Path: "err path",
        Op:   "err op",
        Err:  errors.New("path err"),
    }
        // 无法确定wrappedErr的类型
    wrappedErr := fmt.Errorf("wrappedErr %w", err)
    if _, ok := wrappedErr.(*os.PathError); ok {
        fmt.Println("assert wrappedErr  os.PathError")
    }
        // 用As来断言wrappedErr的类型
    var perr *os.PathError
    if errors.As(wrappedErr, &perr) {
        fmt.Println("as wrappedErr os.PathError")
    }
}
>>> as wrappedErr  os.PathError