Go语言的errors包有4个方法：
errors.Aserrors.Iserrors.Newerrors.Unwrap
本期我们来揭开他们的神秘面纱。俗话说的好，柿子还得挑软的捏，按照国际惯例我们先从最简单的New函数开始。
在 Go 源码目录的 errors 目录下，有errors.go和wrap.go两个文件，以及对应的errors_test.go和wrap_test.go两个单元测试文件。要学一个新东西时，其实看xxx_test.go是一个非常不错的选择，它会告诉你这些函数该怎么用。说回errors.New函数，它在errors.go文件中定义，其他3个函数都在wrap.go文件中。
errors.go 文件源码如下：
package errorsfunc New(text string) error {return &errorString{text}
}type errorString struct {s string
}func (e *errorString) Error() string {return e.s
}
去掉注释就剩这点内容了，代码就不做解释了。看下Go简洁的编程哲学，errors包中定义了New函数，而没有用NewError，因为Go通过包名调用函数的特性，包命已经说明了上下文。
第二个我们来看errors.Unwrap函数，它的源码如下：
func Unwrap(err error) error {u, ok := err.(interface {Unwrap() error})if !ok {return nil}return u.Unwrap()
}
乍一看好像不明所以，我们把上面的代码重写一下：
type Wraper interface {Unwrap() error
}func Unwrap(err error) error {u, ok := err.(Wraper)if !ok {return nil}return u.Unwrap()
}
现在就清楚多了，首先断言err是否实现了匿名接口interface{ Unwrap() error }，如果实现了这个接口就调用它的Unwrap函数，否则返回nil。通过Unwrap函数，就可以生成一条错误链。
再来看errors.Is函数。源码如下：
// Is用来判断错误链中是否有错误和target匹配.
// 错误链由err以及重复调用Unwrap得到的error组成。
// err和target匹配的条件是他俩相等或者err实现了Is函数并且该函数返回true.
// 通过提供Is方法，一个错误类型可以和一个现有错误等同。例如，MyError定义了如下方法：
// func (m MyError) Is(target error) bool { return target == os.ErrExist }
// 此时 Is(MyError{}, os.ErrExist) 返回true. 参见标准库的syscall.Errno.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}// TODO: consider supporting target.Is(err). This would allow// user-definable predicates, but also may allow for coping with sloppy// APIs, thereby making it easier to get away with them.if err = Unwrap(err); err == nil {return false}}
}
Is函数中也有一个匿名接口interface{ Is(error) bool }，逻辑还是很简单的，唯一吸引眼球的是它的反射用的是reflectlite包，而不是我们熟知的reflect包。reflectlite是一个内部使用的包，并不对外公开，基本套路和reflect大同小异，以你对reflaect包的理解套用到reflectlite包也是可以的。
最后看errors.As函数。源码如下：
// 寻找错误链中第一个和target匹配的error，如果能找到，将err的值设置到target并返回true，否则返回false。
// 错误链由err以及重复调用Unwrap得到的error组成。
// 如果err可以赋值给target或者err有As(实现了匿名接口)函数并且As函数返回true，则err和target是匹配的。
// 在后一种情况下，由As函数负责设置target。
// 提供了As方法的error可以视为另一种类型的错误。
// 如果target既不是error类型也不是接口类型，As函数会panic
func As(err error, target interface{}) 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")}if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {panic("errors: *target must be interface or implement error")}targetType := typ.Elem()for err != nil {if reflectlite.TypeOf(err).AssignableTo(targetType) {val.Elem().Set(reflectlite.ValueOf(err))return true}if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {return true}err = Unwrap(err)}return false
}var errorType = reflectlite.TypeOf((*error)(nil)).Elem()
As 函数就要复杂一点了，不过流程还是很清晰的，和Is函数的流程一般无二。这里用到了较多的反射，我们可以看下当err和target匹配时的处理val.Elem().Set(reflectlite.ValueOf(err))。
val是target反射出的Value。Elem方法可以获取元素值的Value，具体来说就是接口包含的值、指针指向的值、以及容器类型(切片|map|通道)包含的值。当然reflectlite包的Elem函数只支持接口和指针，这也是它和reflect包不同的地方，也因此As方法要求target必须是指针类型。如果你打开Elem函数的实现，就能看到下面的注释：
// Elem returns the value that the interface v contains or that the pointer v points to.
// It panics if v's Kind is not Interface or Ptr.
// It returns the zero Value if v is nil.
三句英文清晰明了，相信不用我再翻译了。言归正传，当err和target匹配时，将err反射出来的Value设置给了target。我们知道Value结构体有三个字段：
- 一个
rtype类型的指针，表示类型信息 - 一个
unsafe.Pointer，指向数据的指针 - 一个flag
那么Value的Set方法干了啥呢？不妨看下源代码：
// Set assigns x to the value v.
// It panics if CanSet returns false.
// As in Go, x's value must be assignable to v's type.
func (v Value) Set(x Value) {v.mustBeAssignable()x.mustBeExported() // 防止泄露非导出字段var target unsafe.Pointerif v.kind() == Interface {target = v.ptr}x = x.assignTo("reflectlite.Set", v.typ, target)if x.flag&flagIndir != 0 {typedmemmove(v.typ, v.ptr, x.ptr)} else {*(*unsafe.Pointer)(v.ptr) = x.ptr}
}
先不要对flagIndir和typedmemmove感到疑惑，if和else分支的目的都是一样的，那就是替换Value中那个指向数据的指针ptr。
所以当err和target匹配时，As函数用err的值替换了target的数据，但是保留了target的类型。
最后我们再来看flagIndir和typedmemmove的问题。flagIndir是个啥在Value的源码中有说明：
type Value struct {typ *rtype// Pointer-valued data or, if flagIndir is set, pointer to data.// Valid when either flagIndir is set or typ.pointers() is true.ptr unsafe.Pointer// flag holds metadata about the value.// The lowest bits are flag bits:// - flagIndir: val holds a pointer to the dataflag
}type flag uintptrconst (flagKindWidth = 5 // there are 27 kindsflagKindMask flag = 1<<flagKindWidth - 1flagStickyRO flag = 1 << 5flagEmbedRO flag = 1 << 6flagIndir flag = 1 << 7flagAddr flag = 1 << 8flagMethod flag = 1 << 9flagMethodShift = 10flagRO flag = flagStickyRO | flagEmbedRO
)flagIndir是一个标识，表示Value的ptr字段究竟是指向数据还是指向指针。如果设置了flagIndir，则ptr指向指针，如果没有设置，则ptr指向数据。更多内容可以参见这篇文章。我们还可以通过下面的代码来验证这一点。
type MyValue struct {typ uint64ptr unsafe.Pointerflag
}type flag uintptrvar flagIndir flag = 1 << 7func main() {var a = 1var p = &avala := reflect.ValueOf(a)valp := reflect.ValueOf(p)myVal := (*MyValue)(unsafe.Pointer(&vala))fmt.Printf("%b\n", myVal.flag)fmt.Println(myVal.flag & flagIndir)fmt.Println("---")myVal = (*MyValue)(unsafe.Pointer(&valp))fmt.Printf("%b\n", myVal.flag)fmt.Println(myVal.flag & flagIndir)
}//===== 输出 =====//
10000010
128
---
10110
0
//===============//
所以Value.Set函数的逻辑如下：
- 如果
Value指向的是指针，那么可以直接赋值； - 如果
Value指向的是数据，那么调用typedmemmove函数将x.ptr指向的数据拷贝到v.ptr指向的内存，拷贝多少字节由类型v.typ决定。
typedmemmove函数在源码中只有一个函数定义，应该是一个汇编函数，遗憾的是我只在runtime包找到了memmove函数的汇编实现，没找到typedmemmove的汇编实现。
// typedmemmove copies a value of type t to dst from src.
//go:noescape
func typedmemmove(t *rtype, dst, src unsafe.Pointer)
既然都说到这儿了，那就不得不提一嘴github.com/pkg/errors包，它也提供了 New、Unwrap、Is、As 这4个函数，那么他们和标准库的函数有啥区别呢？
其实github.com/pkg/errors包的Unwrap、Is、As 函数就是直接调用的标准库errors的函数。New函数有点区别，它返回的结构体除了有错误信息还有调用栈。
github.com/pkg/errors包在标准库的基础上提供了更多的函数。比如提供了Wrap函数包装错误，提供了Cause接口获取底层错误。并且它提供的错误类型是实现了Cause和Unwrap接口的，不需要我们自己去定义错误类型实现接口了，此外还提供了调用栈。使用它应该能获得不错的体验，减少自己自定义错误类型。
