type error interface {
    Error() string
}Copy

//src/errors/errors.go

func New(text string) error {
    return &errorString{text}
}

type errorString struct {
    s string
}

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

func Sqrt(f float64)(float64, error) {
    if f < 0 {
        return 0, errors.New("math:square root of negative number")
    }
    // implementation
}Copy

It is the error implemetation's responsibility to summarize the context.Copy

if f <0 {
    return 0, fmt.Errorf("math: square root of negative number %g", f)
}Copy

fmt.Println(err)Copy

fmt.Println(err.Error)Copy

... err := errors.New("error example")
fmt.Printf("The returned error is %s.\n", err)Copy

err := doStuff1() 
if err != nil {
    // handle error... 
}

err = doStuff2() 
if err != nil {
    // handle error... 
}
err = doStuff3() 
if err != nil {
    // handle error... }Copy

func main() {
    r := bytes.NewReader([]byte("0123456789"))

    _, err := r.Read(make([]byte, 10)) 
    if err == io.EOF {
        log.Fatal("read failed:", err) 
    }
}Copy

func main() {
    err := readfile(“.bashrc”)
    if strings.Contains(error.Error(), "not found") {
        // handle error 
    }
}

func readfile(path string) error { 
    err := openfile(path) 
    if err != nil {
        return fmt.Errorf("cannot open file %s: %v", path, err) 
    }
    //...... 
}Copy

// src/os/error.go

// PathError records an error and the operation and file path that caused it. 
type PathError struct {
    Op string 
    Path string 
    Err error
}Copy

// underlyingError returns the underlying error for known os error types.
func underlyingError(err error) error { 
    switch err := err.(type) {
    case *PathError:
        return err.Err 
    case *LinkError:
        return err.Err 
    case *SyscallError:
        return err.Err 
    }
    return err 
}Copy

func fn() error {
    x, err := bar.Foo()
    if err != nil { 
        return err
    }
    //usex
    return nil 
}Copy

type temporary interface { 
    Temporary() bool
}

func IsTemporary(err error) bool { 
    te, ok := err.(temporary) 
    return ok && te.Temporary()
}Copy

func AuthenticateRequest(r *Request) error { 
    err := authenticate(r.User) 
    if err != nil {
        return err 
    }
    return nil 
}Copy

func AuthenticateRequest(r *Request) error { 
    return authenticate(r.User)
}Copy

func AuthenticateRequest(r *Request) error { 
    err := authenticate(r.User) 
    if err != nil {
        return fmt.Errorf("authenticate failed: %v", err)
    }
    return nil 
}Copy

// Wrap annotates cause with a message.
func Wrap(cause error, message string) error
// Cause unwraps an annotated error.
func Cause(err error) errorCopy

func ReadFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, errors.Wrap(err, "open failed") 
    }
    defer f.Close()
    buf, err := ioutil.ReadAll(f) 
    if err != nil {
        return nil, errors.Wrap(err, "read failed") 
    }
    return buf, nil 
}Copy

func main() {
    _, err := ReadConfig() 
    if err != nil {
        fmt.Println(err)
        os.Exit(1) 
    }
}

func ReadConfig() ([]byte, error) {
    home := os.Getenv("HOME")
    config, err := ReadFile(filepath.Join(home, ".settings.xml")) 
    return config, errors.Wrap(err, "could not read config")
}Copy

could not read config: open failed: open /Users/dfc/.settings.xml: no such file or directoryCopy

func main() {
    _, err := ReadConfig() 
    if err !=nil {
        fmt.Printf("%+v", err)
        os.Exit(1) 
    }
}Copy

open /Users/qcrao/.settings.xml: no such file or directory 
open failed
main.ReadFile 
    /Users/qcrao/go/src/hello/main.go:14
main.ReadConfig 
    /Users/qcrao/go/src/hello/main.go:27
main.main 
    /Users/qcrao/go/src/hello/main.go:32
runtime.main 
    /usr/local/go/src/runtime/proc.go:203
runtime.goexit 
    /usr/local/go/src/runtime/asm_amd64.s:1357
could not read config 
main.ReadConfig
    /Users/qcrao/go/src/hello/main.go:28 
main.main
    /Users/qcrao/go/src/hello/main.go:32 
runtime.main
    /usr/local/go/src/runtime/proc.go:203 
runtime.goexit
    /usr/local/go/src/runtime/asm_amd64.s:1357Copy

type temporary interface { 
    Temporary() bool
}

// IsTemporary returns true if err is temporary. 
func IsTemporary(err error) bool {
    te, ok := errors.Cause(err).(temporary)
    return ok && te.Temporary() 
}Copy

func Write(w io.Writer, buf []byte) {
    w.Write(buf)
}Copy

func Write(w io.Writer, buf []byte) error { 
    _, err := w.Write(buf)
    i ferr != nil {
        // annotated error goes to log file 
        log.Println("unable to write:", err)

        // unannotated error returned to caller 
        return err
    }
    return nil 
}Copy

func Unwrap(err error) error {
    // 判断是否实现了 Unwrap 方法 
    u, ok := err.(interface {
        Unwrap() error 
    })
    // 如果不是，返回 nil 
    if !ok {
        return nil 
    }
    // 调用 Unwrap 方法返回被嵌套的 error
    return u.Unwrap() 
}Copy

func Is(err, target error) bool { 
    if target == nil {
        return err == target 
    }
    isComparable := reflectlite.TypeOf(target).Comparable()
    // 无限循环，比较 err 以及嵌套的 error 
    for {
        if isComparable && err == target { 
            return true
        }
        // 调用 error 的 Is 方法，这里可以自定义实现
        if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
            return true 
        }
        // 返回被嵌套的下一层的 error 
        if err = Unwrap(err); err == nil {
            return false 
        }
    } 
}Copy

func As(err error, target interface{}) bool { 
    // target 不能为 nil
    if target == nil {
        panic("errors: target cannot be nil") 
    }
    val := reflectlite.ValueOf(target) 
    typ := val.Type()

    // target 必须是一个非空指针
    if typ.Kind() != reflectlite.Ptr || val.IsNil() {
        panic("errors: target must be a non-nil pointer") 
    }

    // 保证 target 是一个接口类型或者实现了 Error 接口
    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{
        // 使用反射判断是否可被赋值，如果可以就赋值并且返回 true 
        if reflectlite.TypeOf(err).AssignableTo(targetType) {
            val.Elem().Set(reflectlite.ValueOf(err))
            return true 
        }
        // 调用 error 自定义的 As 方法，实现自己的类型断言代码
        if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
            return true 
        }
        // 不断地 Unwrap，一层层的获取嵌套的 error
        err = Unwrap(err) 
    }
    return false 
}Copy

本文章首发在 LearnKu.com 网站上。