理解 Go defer

go 的 defer 语句是用来延迟执行函数的，并且延迟发生在调用函数 return以后

defer 的做用和执行时机

go 的 defer 语句是用来延迟执行函数的，并且延迟发生在调用函数 return以后，好比

func a() int {
    defer b()
    return 0
}
复制代码

b 的执行是发生在 return 0 以后，注意 defer 的语法，关键字 defer 以后是函数的调用。

清理释放资源

因为 defer 的延迟特性，defer 经常使用在函数调用结束以后清理相关的资源，好比

f, _ := os.Open(filename)
defer f.Close()
复制代码

文件资源的释放会在函数调用结束以后借助 defer 自动执行，不须要时刻记住哪里的资源须要释放，打开和释放必须相对应。

用一个例子深入诠释一下 defer 带来的便利和简洁。

代码的主要目的是打开一个文件，而后复制内容到另外一个新的文件中，没有 defer 时这样写：

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    dst, err := os.Create(dstName)
    if err != nil { //1
        return
    }
    written, err = io.Copy(dst, src)
    dst.Close()
    src.Close()
    return
}
复制代码

代码在 //1 处返回以后，src 文件没有执行关闭操做，可能会致使资源不能正确释放，改用 defer 实现：

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()
    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    defer dst.Close()
    return io.Copy(dst, src)
}
复制代码

src 和 dst 都能及时清理和释放，不管 return 在什么地方执行。

鉴于 defer 的这种做用，defer 经常使用来释放数据库链接，文件打开句柄等释放资源的操做。

执行 recover

被 defer 的函数在 return 以后执行，这个时机点正好能够捕获函数抛出的 panic，于是 defer 的另外一个重要用途就是执行 recover。

recover 只有在 defer 中使用才更有意义，若是在其余地方使用，因为 program 已经调用结束而提早返回而没法有效捕捉错误。

package main
import (
    "fmt"
)
func main() {
    defer func() {
        if ok := recover(); ok != nil {
            fmt.Println("recover")
        }
    }()
    panic("error")
}
复制代码

记住 defer 要放在 panic 执行以前。

多个 defer 的执行顺序

defer 的做用就是把关键字以后的函数执行压入一个栈中延迟执行，多个 defer 的执行顺序是后进先出 LIFO ：

defer func() { fmt.Println("1") }()
defer func() { fmt.Println("2") }()
defer func() { fmt.Println("3") }()
复制代码

输出顺序是 321。这个特性能够对一个 array 实现逆序操做。

被 deferred 函数的参数在 defer 时肯定

这是 defer 的特色，一个函数被 defer 时，它的参数在 defer 时进行计算肯定，即便 defer 以后参数发生修改，对已经 defer 的函数没有影响，什么意思？看例子：

func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}
复制代码

a 执行输出的是 0 而不是 1，由于 defer 时，i 的值是 0，此时被 defer 的函数参数已经进行执行计算并肯定了。

再看一个例子：

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}
func main() {
    a := 1
    b := 2
    defer calc("1", a, calc("10", a, b))
    a = 0
    return
}
复制代码

执行代码输出

10 1 2 3
1 1 3 4
复制代码

defer 函数的参数 第三个参数在 defer 时就已经计算完成并肯定，第二个参数 a 也是如此，不管以后 a 变量是否修改都不影响。

被 defer 的函数能够读取和修改带名称的返回值

func c() (i int) {
    defer func() { i++ }()
    return 1
}
复制代码

被 defer 的函数是在 return 以后执行，能够修改带名称的返回值，上面的函数 c 返回的是 2。