type error interface { 
    Error() string 
}

func Foo(param int) (n int, err error) { 
    // ...
}

n, err := Foo(0)

if err != nil { 
    // 错误处理 
} else {
    // 使用返回值 n 
}

返回错误实例并打印

 Go 标准错误包 errors 提供的 New() 方法快速创建一个 error 类型的错误实例

func add(a, b int) (c int, err error) {
    if (a < 0 || b < 0) {
        err = errors.New("只支持非负整数相加")
        return
    }
    a *= 2
    b *= 3
    c = a + b
    return
}

参照上面介绍的 Go 错误处理标准模式，调用这个函数并编写错误处理的代码如下

func main() {
    if len(os.Args) != 3 {
        fmt.Printf("Usage: %s num1 num2n", filepath.Base(os.Args[0]))
        return
    }
    x, _ := strconv.Atoi(os.Args[1])
    y, _ := strconv.Atoi(os.Args[2])
    // 通过多返回值捕获函数调用过程中可能的错误信息
    z, err := add(x, y)
    // 通过「卫述语句」处理后续业务逻辑
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("add(%d, %d) = %dn", x, y, z)
    }
}

为了方便测试，我们将通过命令行参数传递 add 函数的参数，这里我们引入了 os 包读取命令行参数，并通过 strconv 包提供的 Atoi 方法将其转化为整型（命令行读取参数值默认是字符串类型，转化时忽略错误以便简化处理流程），然后分别赋值为 x、y 变量，再调用 add 函数进行运算。

注意到我们在打印错误信息时，直接传入了 err 对象实例，因为 Go 底层会自动调用 err 实例上的 Error() 方法返回错误信息并将其打印出来，就像普通类的 String() 方法一样。

我们简单测试下不传递参数、传递错误类型参数和传递正常参数这几种场景，打印结果如下：

 以上这种错误处理已经能够满足我们日常编写 Go 代码时大部分错误处理的需求了，事实上，Go 底层很多包进行错误处理时就是这样做的。此外，我们还可以通过 fmt.Errorf() 格式化方法返回 error 类型错误，其底层调用的其实也是 errors.New 方法：

func Errorf(format string, a ...interface{}) error {
    return errors.New(Sprintf(format, a...))
}

更复杂的错误类型

系统内置错误类型

除了上面这种最基本的、使用 errors.New() 方法返回包含错误信息的错误实例之外，Go 语言内置的很多包还封装了更复杂的错误类型。

以 os 包为例，这个包主要负责与操作系统打交道，所以提供了 LinkError、PathError、SyscallError 这些实现了 error 接口的错误类型，以 PathError 为例，顾名思义，它主要用于表示路径相关的错误信息，比如文件不存在，其底层类型结构信息如下：

type PathError struct {
    Op   string
    Path string
    Err  error
}

该错误类型除了组合 error 接口实现 Error() 方法外，还提供了额外的操作类型字段 Op 和文件路径字段 Path 以丰富错误信息，方便定位问题，该类型的 Error() 方法实现如下：　　

func (e *PathError) Error() string { 
    return e.Op + " " + e.Path + ": " + e.Err.Error() 
}

我们可以在调用 os 包方法出错时通过 switch 分支语句判定具体的错误类型，然后进行相应的处理：

// 获取指定路径文件信息，对应类型是 FileInfo
// 如果文件不存在，则返回 PathError 类型错误
fi, err := os.Stat("test.txt") 
if err != nil {
    switch err.(type) {
    case *os.PathError:
        // do something
    case *os.LinkError:
        // dome something
    case *os.SyscallError:
        // dome something
    case *exec.Error:
        // dome something
    }
} else {
    // ...
}

自定义错误类型

 我们也可以仿照 PathError 的实现自定义一些复杂的错误类型，只需要组合 error 接口并实现 Error() 方法即可，然后按照自己的需要为自定义类型添加一些属性字段，这很简单，就不展开介绍了。

小结

可以看到，Go 语言的错误和其他语言的错误和异常不同，它们就是从函数或者方法中返回的、和其他返回值并没有什么区别的普通 Go 对象而已，如果程序出错，要如何处理程序下一步的动作，是退出程序还是警告后继续执行，决定权完全在开发者手上。

二、defer 语句及其使用

Go 语言中的类没有构造函数和析构函数的概念，处理错误和异常时也没有提供 try...catch...finally 之类的语法，那当我们想要在某个资源使用完毕后将其释放（网络连接、文件句柄等），或者在代码运行过程中抛出错误时执行一段兜底逻辑，要怎么做呢？

通过 defer 关键字声明兜底执行或者释放资源的语句可以轻松解决这个问题。比如我们看 Go 内置的 io/ioutil 包提供的读取文件方法 ReadFile 实现源码，其中就有 defer 语句的使用：

func ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    var n int64 = bytes.MinRead

    if fi, err := f.Stat(); err == nil {
        if size := fi.Size() + bytes.MinRead; size > n {
            n = size
        }
    }
    return readAll(f, n)
}

defer 修饰的 f.Close() 方法会在函数执行完成后或读取文件过程中抛出错误时执行，以确保已经打开的文件资源被关闭，从而避免内存泄露。如果一条语句干不完清理的工作，也可以在 defer 后加一个匿名函数来执行对应的兜底逻辑：

defer func() { 
    //  执行复杂的清理工作... 
} ()

另外，一个函数/方法中可以存在多个 defer 语句，defer 语句的调用顺序遵循先进后出的原则，即最后一个 defer 语句将最先被执行，相当于「栈」这个数据结构，如果在循环语句中包含了 defer 语句，则对应的 defer 语句执行顺序依然符合先进后出的规则。

由于 defer 语句的执行时机和调用顺序，所以我们要尽量在函数/方法的前面定义它们，以免在后面编写代码时漏掉，尤其是运行时抛出错误会中断后面代码的执行，也就感知不到后面的 defer 语句。

下面我们看一段简单的 defer 示例代码：

package main

import "fmt"

func printError()  {
    fmt.Println("兜底执行")
}

func main()  {
    defer printError()
    defer func() {
        fmt.Println("除数不能是0!")
    }()

    var i = 1
    var j = 1
    var k = i / j

    fmt.Printf("%d / %d = %dn", i, j, k)
}

在这段代码中，我们定义了两个 defer 语句，并且是在函数最顶部，以确保异常情况下也能执行。

在函数正常执行的情况下，这两个 defer 语句会在最后一条打印语句执行完成后先执行第二条 defer 语句，再执行第一条 defer 语句

而如果我们把 j 的值设置为 0，则函数会抛出 panic：

 表示除数不能为零。这个时候，由于 defer 语句定义在抛出 panic 代码的前面，所以依然会被执行，底层的逻辑是在执行 var k = i / j 这条语句时，遇到除数为 0，则抛出 panic，然后立即中断当前函数 main 的执行（后续其他语句都不再执行），并按照先进后出顺序依次执行已经在当前函数中声明过的 defer 语句，最后打印出 panic 日志及错误信息

总结一下，Go 语言的 defer 语句相当于 Java/PHP 中的析构函数和 finally 语句的功效，常用于定义兜底逻辑，在函数执行完毕后或者运行抛出 panic 时执行，如果一个函数定义了多个 defer 语句，则按照先进后出的顺序执行 

三、panic 和 recover

Go 语言通过 error 类型统一进行错误处理，但这些错误都是我们在编写代码时就已经预见并返回的，对于某些运行时错误，比如数组越界、除数为0、空指针引用，这些 Go 语言是怎么处理的呢？

panic

除了像上面演示的那样由 Go 语言底层抛出 panic，我们还可以在代码中显式抛出 panic，以便对错误和异常信息进行自定义，仍然以上篇教程除数为 0 的示例代码为例，我们可以这样显式返回 panic 中断代码执行：

package main

import "fmt"

func main() {
    defer func() {
        fmt.Println("代码清理逻辑")
    }()

    var i = 1
    var j = 0
    if j == 0 {
        panic("除数不能为0！")
    }
    k := i / j
    fmt.Printf("%d / %d = %dn", i, j, k)
}

这样一来，当我们执行这段代码时，就会抛出 panic：

panic 函数支持的参数类型是 interface{}：

func panic(v interface{})

panic(500)   // 传入数字
panic(errors.New("除数不能为0"))  // 传入 error 类型

package main

import (
    "fmt"
)

func divide() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Printf("Runtime panic caught: %vn", err)
        }
    }()

    var i = 1
    var j = 0
    k := i / j
    fmt.Printf("%d / %d = %dn", i, j, k)
}

func main() {
    divide()
    fmt.Println("divide 方法调用完毕，回到 main 函数")
}