了解 Go 中的 defer #
简介 #
Go 有许多其他编程语言中常见的控制流关键字，如 if、switch、for 等。有一个关键词在大多数其他编程语言中都没有，那就是 defer ，虽然它不太常见，但你很快就会发现它在你的程序中是多么有用。
defer 语句的主要用途之一是清理资源，如打开的文件、网络连接和数据库句柄。当你的程序使用完这些资源后，关闭它们很重要，以避免耗尽程序的限制，并允许其他程序访问这些资源。defer 通过保持关闭文件/资源的调用与打开调用保持一致，使我们的代码更加简洁，不易出错。
在这篇文章中，我们将学习如何正确使用 defer 语句来清理资源，以及使用 defer 时常犯的几个错误。
什么是 defer 语句
#
defer 语句将 defer 关键字后面的函数调用添加到一个栈中。当该语句所在的函数返回时，将执行堆栈中所有的函数调用。由于这些调用位于堆栈上，因此将按照后进先出的顺序进行调用。
让我们看看 defer 是如何工作的，打印出一些文本：
package main
import "fmt"
func main() {
defer fmt.Println("Bye")
fmt.Println("Hi")
}
在 main 函数中，我们有两条语句。第一条语句以 defer 关键字开始，后面是 print 语句，打印出 Bye。下一行打印出 Hi。
如果我们运行该程序，我们将看到以下输出：
Hi
Bye
请注意，Hi 被首先打印出来。这是因为以 defer 为前缀的语句直到该函数结束前，都不会被调用。
让我们再看看这个程序，这次我们将添加一些注释来帮助说明正在发生的事情：
package main
import "fmt"
func main() {
// defer statement is executed, and places
// fmt.Println("Bye") on a list to be executed prior to the function returning
defer fmt.Println("Bye")
// The next line is executed immediately
fmt.Println("Hi")
// fmt.Println*("Bye") is now invoked, as we are at the end of the function scope
}
理解 defer 的关键是，当 defer 语句被执行时，延迟函数的参数被立即评估。当 defer 执行时，它把后面的语句放在一个列表中，在函数返回之前被调用。
虽然这段代码说明了 defer 的运行顺序，但这并不是编写 Go 程序时的典型使用方式。我们更可能使用 defer 来清理资源，例如文件句柄。接下来让我们看看如何做到这一点。
使用 defer 来清理资源
#
使用 defer 来清理资源在 Go 中是非常常见的。让我们先看看一个将字符串写入文件的程序，但没有使用 defer 来处理资源清理的问题：
package main
import (
"io"
"log"
"os"
)
func main() {
if err := write("readme.txt", "This is a readme file"); err != nil {
log.Fatal("failed to write file:", err)
}
}
func write(fileName string, text string) error {
file, err := os.Create(fileName)
if err != nil {
return err
}
_, err = io.WriteString(file, text)
if err != nil {
return err
}
file.Close()
return nil
}
在这个程序中，有一个叫做 write 的函数，它将首先尝试创建一个文件。如果它有错误，它将返回错误并退出函数。接下来，它试图将字符串 This is a readme file 写到指定文件中。如果它收到一个错误，它将返回错误并退出该函数。然后，该函数将尝试关闭该文件并将资源释放回系统。最后，该函数返回 nil 以表示该函数的执行没有错误。
虽然这段代码可以工作，但有一个细微的错误。如果对 io.WriteString 的调用失败，该函数将在没有关闭文件并将资源释放回系统的情况下返回。
我们可以通过添加另一个 file.Close() 语句来解决这个问题，在没有 defer 的语言中，你可能会这样解决：
package main
import (
"io"
"log"
"os"
)
func main() {
if err := write("readme.txt", "This is a readme file"); err != nil {
log.Fatal("failed to write file:", err)
}
}
func write(fileName string, text string) error {
file, err := os.Create(fileName)
if err != nil {
return err
}
_, err = io.WriteString(file, text)
if err != nil {
file.Close()
return err
}
file.Close()
return nil
}
现在，即使调用 io.WriteString 失败了，我们仍然会关闭该文件。虽然这是一个相对容易发现和修复的错误，但对于一个更复杂的函数来说，它可能会被遗漏。
我们可以使用 defer 语句来确保在执行过程中无论采取何种分支，我们都会调用 Close() ，而不是增加对 file.Close() 的第二次调用。
下面是使用 defer 关键字的版本：
package main
import (
"io"
"log"
"os"
)
func main() {
if err := write("readme.txt", "This is a readme file"); err != nil {
log.Fatal("failed to write file:", err)
}
}
func write(fileName string, text string) error {
file, err := os.Create(fileName)
if err != nil {
return err
}
defer file.Close()
_, err = io.WriteString(file, text)
if err != nil {
return err
}
return nil
}
这一次我们添加了这行代码，defer file.Close()。这告诉编译器，它应该在退出函数 write 之前执行 file.Close。
现在我们已经确保，即使我们在未来添加更多的代码并创建另一个退出该函数的分支，我们也会一直清理并关闭该文件。
然而，我们通过添加 defer 引入了另一个错误。我们不再检查可能从 Close 方法返回的潜在错误。这是因为当我们使用 defer 时，没有办法将任何返回值传回给我们的函数。
在 Go 中，在不影响程序行为的情况下多次调用 Close() 被认为是一种安全和公认的做法。如果 Close() 要返回一个错误，它将在第一次被调用时返回。这使得我们可以在函数的成功执行路径中明确地调用它。
让我们看看我们如何既能 defer 对 Close 的调用，又能在遇到错误时报告错误。
package main
import (
"io"
"log"
"os"
)
func main() {
if err := write("readme.txt", "This is a readme file"); err != nil {
log.Fatal("failed to write file:", err)
}
}
func write(fileName string, text string) error {
file, err := os.Create(fileName)
if err != nil {
return err
}
defer file.Close()
_, err = io.WriteString(file, text)
if err != nil {
return err
}
return file.Close()
}
这个程序中唯一的变化是最后一行，我们返回 file.Close()。如果对 Close 的调用导致错误，现在将按照预期返回给调用函数。请记住，我们的 defer file.Close() 语句也将在 return 语句之后运行。这意味着 file.Close() 有可能被调用两次。虽然这并不理想，但这是可以接受的做法，因为它不应该对你的程序产生任何副作用。
然而，如果我们在函数的早期收到一个错误，例如当我们调用 WriteString 时，函数将返回该错误，并且也将尝试调用 file.Close，因为它被推迟了。尽管 file.Close 也可能（而且很可能）返回一个错误，但这不再是我们关心的事情，因为我们收到的错误更有可能告诉我们一开始就出了什么问题。
到目前为止，我们已经看到我们如何使用一个 defer 来确保我们正确地清理我们的资源。接下来我们将看到如何使用多个 defer 语句来清理多个资源。
多个 defer 语句
#
在一个函数中拥有多个 defer 语句是很正常的。让我们创建一个只有 defer 语句的程序，看看当我们引入多个 defer 时，会发生什么情况：
package main
import "fmt"
func main() {
defer fmt.Println("one")
defer fmt.Println("two")
defer fmt.Println("three")
}
如果我们运行该程序，我们将收到以下输出结果：
three
two
one
注意，顺序与我们调用 defer 语句的顺序相反。这是因为每个被调用的延迟语句都是堆叠在前一个语句之上的，然后在函数退出范围时反向调用（后进先出）。
在一个函数中，你可以根据需要有尽可能多的 defer 调用，但重要的是要记住它们都将以相反的顺序被调用。
现在我们了解了多个延迟的执行顺序，让我们看看如何使用多个延迟来清理多个资源。我们将创建一个程序，打开一个文件，向其写入内容，然后再次打开，将内容复制到另一个文件。
package main
import (
"fmt"
"io"
"log"
"os"
)
func main() {
if err := write("sample.txt", "This file contains some sample text."); err != nil {
log.Fatal("failed to create file")
}
if err := fileCopy("sample.txt", "sample-copy.txt"); err != nil {
log.Fatal("failed to copy file: %s")
}
}
func write(fileName string, text string) error {
file, err := os.Create(fileName)
if err != nil {
return err
}
defer file.Close()
_, err = io.WriteString(file, text)
if err != nil {
return err
}
return file.Close()
}
func fileCopy(source string, destination string) error {
src, err := os.Open(source)
if err != nil {
return err
}
defer src.Close()
dst, err := os.Create(destination)
if err != nil {
return err
}
defer dst.Close()
n, err := io.Copy(dst, src)
if err != nil {
return err
}
fmt.Printf("Copied %d bytes from %s to %s\n", n, source, destination)
if err := src.Close(); err != nil {
return err
}
return dst.Close()
}
我们添加了一个新的函数，叫做 fileCopy。在这个函数中，我们首先打开我们要复制的源文件。我们检查我们是否收到了一个打开文件的错误。如果是的话，我们 return 错误并退出该函数。否则，我们 defer 关闭我们刚刚打开的源文件。
接下来我们创建目标文件。再次，我们检查我们是否收到了创建文件的错误。如果是的话，我们 return 该错误并退出该函数。否则，我们也 defer 目标文件的 Close()。我们现在有两个 defer 函数，当函数退出其作用域时将被调用。
现在我们已经打开了两个文件，我们将Copy() 数据从源文件到目标文件。如果成功的话，我们将尝试关闭两个文件。如果我们在试图关闭任何一个文件时收到错误，我们将 return 错误并退出函数作用域。
注意，我们为每个文件明确地调用 Close()，尽管 defer 也将调用 Close()。这是为了确保如果关闭文件时出现错误，我们会报告这个错误。这也确保了如果因为任何原因函数提前退出，例如我们在两个文件之间复制失败，每个文件仍将尝试从延迟调用中正确关闭。
总结 #
在这篇文章中，我们了解了 defer 语句，以及如何使用它来确保我们在程序中正确清理系统资源。正确地清理系统资源将使你的程序使用更少的内存，表现更好。要了解更多关于 defer 的使用，请阅读处理恐慌的文章，或者探索我们整个如何在 Go 中编码系列。