本文承接第一部分的内容继续讲解 defer 的一些常见陷阱

1——Z 到 A（译注：倒序）

当你第一次学习 Go 的时候可能会中招。

例子

func main() {
 for i := 0; i < 4; i++ {
 defer fmt.Print(i)
 }} 

输出

Go 的运行时会将延迟执行的函数保存至一个栈中（译注：意味着它们会按照入栈的顺序倒序执行）。想了解更多，请阅读这篇 文章 GCTT 出品的译文：图解 Go 中的延迟调用 defer。

3
2
1
0 

2——作用域屏蔽了参数

事实上这是一个作用域的坑，但我想要让你知道它与 defer 和 已命名的返回值 之间的关系。

例子

这里我们定义了一个函数，这个函数声明了它需要延迟的函数（在返回的时候释放资源 r ）。

接着创建一个 reader 类型的结构体使得调用 Close 的时候返回一个 error

type reader struct{}func (r reader) Close() error {
 return errors.New("Close Error")} 

当 reader 调用 Close() 的时候总会返回一个 error ， release 会在 defer 内部调用。

r := reader{}
err := release(r)
fmt.Print(err) 

输出

 nil  

变量 err 的值为 nil ，而我们期望中的值应该是 “Close Error” 。

为什么会这样？

延迟函数内的 赋值语句 在延迟函数的 if 块中，因此在块中的 err 变量赋值会创建一个全新的变量，块级变量 err 的作用域会屏蔽返回变量 err ，因此， release() 还是返回 err 的原始值。

解决方案

我们需要将值赋给 release() 的 err 变量，为了做到这一点，请看下面图示的第三行，这行代码并没有声明新的 err 变量，与之前不同的是，它使用的是原本的 err 返回变量（将 := 替换成 = ）。这就解决了块级屏蔽的问题。

如果你对 = 和 := ，请看一下这篇 文章

3——参数很快得到了值

当一个 defer 函数出现而不是被执行的时候，传递给它的参数的值就会被立刻确定下来，在我的其他文章中有讲过类似的 例子 。

例子

type  message  struct {
 content string
}

func (p *message) set(c string) {
 p.content = c
}

func (p *message) print() string {
 return p.content
} 

试着运行一下上面的代码

func() {
 m := &message{content: "Hello"}
 defer fmt.Print(m.print())
 m.set("World")
 // 被延迟的函数在这里执行
} 

输出

"Hello" 

为什么输出不是 “World” ?

在 defer 中， fmt.Print 被推迟到函数返回后执行，可是 m.print() 的值在当时就已经被求出，因此， m.print() 会返回 “Hello”，这个值会保存一直到外围函数返回。

这个过程类似于调用 fmt.Print() 打印 “Hello” ，进一步理解这个过程，可以看这篇 文章 。

4——循环中存址

当延迟函数执行的时候，会查看当时周围变量中的值 —— 除了被传入参数的值。我们来看看这一切是怎么在循环中发生的。

例子

我们在循环里定义了一个闭包函数。

for i := 0; i < 3; i++ {
 defer func() {
 fmt.Println(i)
 }()
} 

输出

3
3
3 

为什么？

当代码执行的时候，被延迟的函数会查看当时 i 的值，这是因为，当 defer 出现的时候， Go 的运行时会保存 i 的地址，在 for 循环结束之后 i 的值变成了 3。 因此，当延迟语句运行的时候，所有的延迟栈中的语句都会去查看 i 地址中的值，也就是 3 （被当做循环结束后的当时值）。

所有的延迟函数会查看相同的 i ，循环结束（值变成了3)，因此它们查看到的都是 3 。

解决方案

直接向延迟函数传参数。

for i := 0; i < 3; i++ {
 defer func(i int) {
 fmt.Println(i)
 }(i)
} 

2
1
0 

为什么这个又能正常执行？

因为，这时 Go 的运行时在 for 循环的作用域中又创建了不同的 i 变量并把正确的值也保存在了那些变量中，现在，延迟函数不会去查看原始循环中的 i 变量，它们会查看各自的局部 i 变量。

解决方案 #2

在这里，我们故意使用一个新的 i 块级变量来屏蔽循环中的 i ，说实话我不太喜欢这种风格，所以我把这种方式放到了 Hacker News 上供大家讨论。

for i := 0; i < 3; i++ {
 i := i defer func() {
 fmt.Println(i)
 }()
} 

解决方案 #3

如果一次延迟调用一个函数，你可以直接对这个函数使用 defer 。

for i := 0; i < 3; i++ {
 defer fmt.Println(i)
} 

5——不返回的意义

对于调用者来说，在延迟函数中返回值几乎没有什么影响，可是，你依然可以使用 命名返回值 来影响返回的结果。

例子

func release() error {
 defer func() error {
 return errors.New("error")
 }()
 return nil
} 

输出

nil 

解决方案

func release() (err error) {
 defer func() {
 err = errors.New("error")
 }()
 return nil
} 

输出

"error" 

为什么能起作用？

在这里，我们在 defer 中，对 函数的 err 返回变量赋了新的值，并且函数会返回那个值，defer 函数并不直接返回值，它影响了返回命名变量的这个过程。

小结

你不需要处处使用 defer ，没有 defer 你也可以直接返回 error 。

在函数有多个返回情况而你想要集中处理它们的时候使用 defer 会很方便，多思考如何进一步简化你的代码。

---

via:

作者：Inanc Gumus 译者：yujiahaol68 校对：polaris1119

本文由 GCTT 原创编译，Go语言中文网 荣誉推出

---

本文由 GCTT 原创翻译，Go语言中文网 首发。也想加入译者行列，为开源做一些自己的贡献么？欢迎加入 GCTT！

翻译工作和译文发表仅用于学习和交流目的，翻译工作遵照 CC-BY-NC-SA 协议规定，如果我们的工作有侵犯到您的权益，请及时联系我们。

欢迎遵照 CC-BY-NC-SA 协议规定 转载，敬请在正文中标注并保留原文/译文链接和作者/译者等信息。

文章仅代表作者的知识和看法，如有不同观点，请楼下排队吐槽