Go Error 的底实设计哲学是 「Errors Are Values」。

这句话应该怎么理解呢?底实翻译起来挺难的。不过从源码的底实角度来看，好像更容易理解其背后的底实含义。

Go Error 源码很简单，底实寥寥几行：

// src/builtin/builtin.go type error interface {  Error() string } 

error 是底实一个接口类型，只需要实现 Error() 方法即可。底实在 Error() 方法中，底实就可以返回自定义结构体的底实任意内容。

下面首先说说如何创建 error。底实

创建 Error

创建 error 有两种方式，底实分别是底实：

errors.New(); fmt.Errorf()。

errors.New()

errors.New() 的底实使用延续了 Go 的一贯风格，New 一下就可以了。底实

举一个例子：

package main import (  "errors"  "fmt" ) func main() {  err := errors.New("这是底实 errors.New() 创建的错误")  fmt.Printf("err 错误类型：%T，错误为：%vn", err, err) } /* 输出 err 错误类型：*errors.errorString，错误为：这是 errors.New() 创建的错误 */ 

这段代码唯一让人困惑的地方可能就是错误类型了，但没关系。源码库只要看一下源码，就瞬间迎刃而解。

源码如下：

// src/errors/errors.go // New returns an error that formats as the given text. // 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 } 

可以看到，errorString 是一个结构体，实现了 Error() 方法，New 函数直接返回 errorString 指针。

这种用法很简单，但不实用。假如我还想返回程序的上下文信息，它就没辙了。

下面看第二种方式。

fmt.Errorf()

还是先看一个例子：

package main import (  "database/sql"  "fmt" ) func foo() error {  return sql.ErrNoRows } func bar() error {  return foo() } func main() {  err := bar()  if err == sql.ErrNoRows {   fmt.Printf("data not found, %+vn", err)   return  }  if err != nil {   fmt.Println("Unknown error")  } } /* 输出 data not found, sql: no rows in result set */ 

这个例子输出了我们想要的结果，但是还不够。

一般情况下，我们会通过使用 fmt.Errorf() 函数，附加上我们想添加的文本信息，使返回内容更明确，处理起来更灵活。

所以，foo() 函数会改成下面这样：

func foo() error {    return fmt.Errorf("foo err, %v", sql.ErrNoRows) } 

这时问题就出现了，经过 fmt.Errorf() 的封装，原始 error 类型发生了改变，这就导致 err == sql.ErrNoRows 不再成立，返回信息变成了 Unknown error。

如果想根据返回的 error 类型做不同处理，免费源码下载就无法实现了。

因此，Go 1.13 为我们提供了 wrapError 来处理这个问题。

Wrap Error

看一个例子：

package main import (  "fmt" ) type myError struct{} func (e myError) Error() string {  return "Error happended" } func main() {  e1 := myError{}  e2 := fmt.Errorf("E2: %w", e1)  e3 := fmt.Errorf("E3: %w", e2)  fmt.Println(e2)  fmt.Println(e3) } /* output E2: Error happended E3: E2: Error happended */ 

乍一看好像好没什么区别，但背后的实现原理却并不相同。

Go 扩展了 fmt.Errorf() 函数，增加了一个 %w 标识符来创建 wrapError。

// src/fmt/errors.go func Errorf(format string, a ...interface{}) 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 } 

当使用 w% 时，函数会返回 &wrapError{s, p.wrappedErr}，wrapError 结构体定义如下：

// src/fmt/errors.go type wrapError struct {  msg string  err error } func (e *wrapError) Error() string {  return e.msg } func (e *wrapError) Unwrap() error {  return e.err } 

实现了 Error() 方法，说明它是一个 error，而 Unwrap() 方法是为了获取被封装的 error。

// src/errors/wrap.go func Unwrap(err error) error {  u, ok := err.(interface {   Unwrap() error  })  if !ok {   return nil  }  return u.Unwrap() } 

它们之间的关系是这样的：

因此，我们可以使用 w% 将上文中的程序进行改造，使其内容输出更丰富。

如下：

package main import (  "database/sql"  "errors"  "fmt" ) func bar() error {  if err := foo(); err != nil {   return fmt.Errorf("bar failed: %w", foo())  }  return nil } func foo() error {  return fmt.Errorf("foo failed: %w", sql.ErrNoRows) } func main() {  err := bar()  if errors.Is(err, sql.ErrNoRows) {   fmt.Printf("data not found,  %+vn", err)   return  }  if err != nil {   fmt.Println("Unknown error")  } } /* output data not found,  bar failed: foo failed: sql: no rows in result set */ 

终于有了让人满意的输出结果，每个函数都增加了必要的上下文信息，而且也符合对错误类型的判断。

errors.Is() 函数用来判断 err 以及其封装的 error 链中是否包含目标类型。这也就解决了上文提出的网站模板无法判断错误类型的问题。

后记

其实，Go 目前对 Error 的处理方式也是充满争议的。不过，官方团队正在积极和社区交流，提出改进方法。相信在不久的将来，一定会找到更好的解决方案。

现阶段来说，大部分团队可能会选择 github.com/pkg/errors 包来进行错误处理。如果感兴趣的话，可以学学看。

(责任编辑：IT科技)