这个小东西坏的很，一不留神就出错
一、
先来一个简单的例子热热身：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package main import ( "fmt" ) func main() { defer func() { fmt.Println("first") }() defer func() { fmt.Println("second") }() fmt.Println("done") } |
输出：
second
first
这个比较简单，defer 语句的执行顺序是按调用 defer 语句的倒序执行。
二、
看看这段代码有什么问题？
|
1 2 3 4 5 6 7 |
for _, filename := range filenames { f, err := os.Open(filename) if err != nil { return err } defer f.Close() } |
这段代码其实很危险，很可能会用尽所有文件描述符。因为 defer 语句不到函数的最后一刻是不会执行的，也就是说文件始终得不到关闭。所以切记，一定不要在 for 循环中使用 defer 语句。
那怎么优化呢？可以将循环体单独写一个函数，这样每次循环的时候都会调用关闭函数。
如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
for _, filename := range filenames { if err := doFile(filename); err != nil { return err } } func doFile(filename string) error { f, err := os.Open(filename) if err != nil { return err } defer f.Close() } |
三、
看看这三个函数的输出结果是什么？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package main import ( "fmt" ) func a() (r int) { defer func() { r++ }() return 0 } func b() (r int) { t := 5 defer func() { t = t + 5 }() return t } func c() (r int) { defer func(r int) { r = r + 5 }(r) return 1 } func main() { fmt.Println("a = ", a()) fmt.Println("b = ", b()) fmt.Println("c = ", c()) } |
公布答案：
b = 5
c = 1
你答对了吗？
说实话刚开始看到这个结果时，我是相当费解，完全不知道怎么回事。
但可以看到，这三个函数都有一个共同特点，它们都有一个命名返回值，并且都在函数中引用了这个返回值。
引用的方式分两种：分别是闭包和函数参数。
先看 a() 函数：
闭包通过 r++ 修改了外部变量，返回值变成了 1。
相当于：
|
1 2 3 4 5 6 7 8 |
func aa() (r int) { r = 0 // 在 return 之前，执行 defer 函数 func() { r++ }() return } |
再看 b() 函数：
闭包内修改的只是局部变量 t，而外部变量 t 不受影响，所以还是返回 5。
相当于：
|
1 2 3 4 5 6 7 8 9 10 11 |
func bb() (r int) { t := 5 // 赋值 r = t // 在 return 之前，执行 defer 函数 // defer 函数没有对返回值 r 进行修改，只是修改了变量 t func() { t = t + 5 }() return } |
最后是 c 函数：
参数传递是值拷贝，实参不受影响，所以还是返回 1。
相当于：
|
1 2 3 4 5 6 7 8 9 10 |
func cc() (r int) { // 赋值 r = 1 // 这里修改的 r 是函数形参的值 // 值拷贝，不影响实参值 func(r int) { r = r + 5 }(r) return } |
那么，为了避免写出这么令人意外的代码，最好在定义函数时就不要使用命名返回值。或者如果使用了，就不要在 defer 中引用。
再看下面两个例子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
func d() int { r := 0 defer func() { r++ }() return r } func e() int { r := 0 defer func(i int) { i++ }(r) return 0 } d = 0 e = 0 |
返回值符合预期，再也不用绞尽脑汁猜了。
四、
defer 表达式的函数如果在 panic 后面，则这个函数无法被执行。
|
1 2 3 4 5 6 |
func main() { panic("a") defer func() { fmt.Println("b") }() } |
输出如下，b 没有打印出来。
goroutine 1 [running]:
main.main()
xxx.go:87 +0x4ce
exit status 2
而如果 defer 在前，则可以执行。
|
1 2 3 4 5 6 |
func main() { defer func() { fmt.Println("b") }() panic("a") } |
输出：
panic: a
goroutine 1 [running]:
main.main()
xxx.go:90 +0x4e7
exit status 2
五、
看看下面这段代码的执行顺序：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
func G() { defer func() { fmt.Println("c") }() F() fmt.Println("继续执行") } func F() { defer func() { if err := recover(); err != nil { fmt.Println("捕获异常:", err) } fmt.Println("b") }() panic("a") } func main() { G() } |
顺序如下：
-
调用
G()函数； -
调用
F()函数； -
F()中遇到panic，立刻终止，不执行panic之后的代码； -
执行
F()中defer函数，遇到recover捕获错误，继续执行defer中代码，然后返回； -
执行
G()函数后续代码，最后执行G()中defer函数。
输出：
b
继续执行
c
六、
看看下面这段代码的执行顺序：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
func G() { defer func() { fmt.Println("c") }() F() fmt.Println("继续执行") } func F() { defer func() { fmt.Println("b") }() panic("a") } func main() { G() } |
顺序如下：
-
调用
G()函数； -
调用
F()函数； -
F()中遇到panic，立刻终止，不执行panic之后的代码； -
执行
F()中defer函数，由于没有recover，则将panic抛到G()中； -
G()收到panic则不会执行后续代码，直接执行defer函数； -
由于没有
recover，直接抛出F()抛过来的异常a，然后退出。
输出：
c
panic: a
goroutine 1 [running]:
main.F()
xxx.go:90 +0x5b
main.G()
xxx.go:82 +0x48
main.main()
xxx.go:107 +0x4a5
exit status 2
七、
看看下面这段代码的执行顺序：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
func G() { defer func() { // goroutine 外进行 recover if err := recover(); err != nil { fmt.Println("捕获异常:", err) } fmt.Println("c") }() // 创建 goroutine 调用 F 函数 go F() time.Sleep(time.Second) } func F() { defer func() { fmt.Println("b") }() // goroutine 内部抛出panic panic("a") } func main() { G() } |
顺序如下：
-
调用
G()函数； -
通过 goroutine 调用
F()函数； -
F()中遇到panic，立刻终止，不执行panic之后的代码； -
执行
F()中defer函数，由于没有recover，则将panic抛到G()中； -
由于 goroutine 内部没有进行
recover，则 goroutine 外部函数，也就是G()函数是没办法捕获的，程序直接崩溃退出。
输出：
panic: a
goroutine 6 [running]:
main.F()
xxx.go:96 +0x5b
created by main.G
xxx.go:87 +0x57
exit status 2
八、
最后再说一个 recover 的返回值问题：
|
1 2 3 4 5 6 |
defer func() { if err := recover(); err != nil { fmt.Println("捕获异常:", err.Error()) } }() panic("a") |
recover 返回的是 interface {} 类型，而不是 error 类型，所以这样使用的话会报错：
可以这样来转换一下：
|
1 2 3 4 5 6 |
defer func() { if err := recover(); err != nil { fmt.Println("捕获异常:", fmt.Errorf("%v", err).Error()) } }() panic("a") |
或者直接打印结果：
|
1 2 3 4 5 6 |
defer func() { if err := recover(); err != nil { fmt.Println("捕获异常:", err) } }() panic("a") |
输出：
以上就是本文的全部内容，其实写过其他的语言的同学都知道，关闭文件句柄，释放锁等操作是很容易忘的。而 Go 语言通过 defer 很好地解决了这个问题，但在使用过程中还是要小心。
浏览量: 3