编写程序时,像关闭文件、断开连接这类收尾工作,很容易因为代码较长或中途提前退出而忘记执行。Go 语言专门提供了一个非常实用的关键字 defer,它的英文原意就是 “推迟、延后”。
只要我们在一条函数调用语句前面加上 defer,这条语句就不会在当前位置立即运行,而是会自动推迟到当前函数即将返回之前才执行。
defer 基本用法
在 Go 语言中,使用 defer 的语法非常简单,我们只需要在普通的函数调用前面加上 defer 关键字即可。
语法:
defer 函数名(参数列表)说明:
当程序执行到带有 defer 的语句时,系统会先把这次函数调用记录下来,然后继续往下执行后面的普通代码。等到当前函数执行到末尾,或者中途遇到 return 语句即将退出之前,系统才会自动执行刚才推迟的 defer 语句。
示例 1:使用 defer 推迟执行
package main
import "fmt"
func main() {
fmt.Println("程序开始")
defer fmt.Println("[defer] 延迟执行")
fmt.Println("程序结束")
}运行结果如下。
程序开始
程序结束
[defer] 延迟执行分析:
在上面代码中,虽然 defer fmt.Println("[defer] 延迟执行") 写在第 2 行,但它并没有紧跟着第 1 句打印出来。
程序会先按顺序执行完 "程序开始" 和 "程序结束" 这两句普通代码。等到整个 main() 函数即将退出时,系统才回头执行被推迟的打印语句。
注意:
- 后面必须跟函数调用:
defer关键字后面必须跟一个完整的函数调用,也就是末尾必须带有小括号 ()。比如写成defer x = 10就是错误的,编译时会直接报错。 - 归属于整个函数而非局部代码块:哪怕把
defer写在if或for的花括号 {} 内部,它也不会在离开这层花括号时执行,而是依然要等到当前整个函数即将结束时才执行。
多个 defer 的执行顺序
如果在同一个函数内部连续写了多条 defer 语句,函数结束时它们会按照什么顺序执行呢?
在 Go 语言中,多个 defer 语句遵循 “后进先出(LIFO)” 的倒序规则,也就是越晚写下的 defer 语句越早执行。
这个过程和日常生活中的 “叠盘子” 是一个道理:第 1 个盘子放在最底下,第 2 个叠在中间,第 3 个放在最顶上。等我们需要把盘子拿出来使用时,自然是从最顶上的第 3 个开始往下拿,顺序依次是 3、2、1。
示例 2:多个 defer 的执行顺序
package main
import "fmt"
func main() {
fmt.Println("开始执行")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println("普通代码执行完毕")
}运行结果如下。
开始执行
普通代码执行完毕
3
2
1分析:
在这个例子中,我们在 main() 函数内依次写下了打印 1、2、3 的 3 条 defer 语句。当普通代码全部执行完毕后,这 3 条语句会按照从下往上的倒序依次执行,因此最终输出了 3、2、1。
多个 defer 语句的记录与执行顺序如下图所示。

defer 参数的求值时机
使用 defer 时有一个小伙伴们很容易忽略的细节:虽然 defer 后面的函数会推迟到最后才执行,但传给该函数的参数,在程序走到 defer 那一行时就已经立即算出并固定下来了。
示例 3:defer 参数立即求值
package main
import "fmt"
func main() {
x := 10
defer fmt.Println("defer 中的 x =", x)
x = 20
fmt.Println("修改后的 x =", x)
}运行结果如下。
修改后的 x = 20
defer 中的 x = 10分析:
defer 明明是在函数最后才执行的,那时 x 已经改成了 20,为什么打印出来的还是 10 呢?
这是因为当程序运行到 defer fmt.Println("defer 中的 x =", x) 这一行时,系统就已经把当时 x 的值 10 读取出来并保存好了,只是把打印动作推迟到了函数末尾。因此后面我们再把 x 修改为 20,并不会改变前面已经固定下来的参数值。
如果我们确实希望在函数结束时读取到 x 修改后的最新值,应该怎么写呢?这时可以配合前面学过的匿名函数,把打印语句包在一个无参匿名函数里延迟执行。
示例 4:配合匿名函数读取最新值
package main
import "fmt"
func main() {
x := 10
defer func() {
fmt.Println("defer 中的 x =", x)
}()
x = 20
fmt.Println("修改后的 x =", x)
}运行结果如下。
修改后的 x = 20
defer 中的 x = 20分析:
这里小伙伴们还要留意一点:因为 defer 后面必须跟一个函数调用,所以匿名函数右花括号末尾必须加上一对小括号 ()。
这个无参匿名函数没有通过参数传值,而是直接引用了外部变量 x,与 x 构成了闭包。因为闭包捕获的是变量 x 本身而不是创建时的数值快照,等到 main() 函数即将结束、真正执行匿名函数内部的代码时再去读取 x,拿到的就是修改后的最新值 20 了。
defer 的应用场景
在实际开发中,defer 最常见的用途就是 “成对管理资源的打开与关闭”。比如我们在读取文件或连接数据库时,打开资源之后必须记得把它关闭。
如果不使用 defer,当函数代码较长或者中途有多处 return 提前返回时,我们很容易漏写关闭代码。有了 defer 之后,只要在打开资源的下一行紧挨着写好关闭操作,无论函数从哪个分支退出都能自动清理资源。
示例 5:自动释放打开的资源
package main
import "fmt"
func readData(isValid bool) {
fmt.Println("[打开] 打开文件资源")
defer fmt.Println("[关闭] 关闭文件资源") // 紧挨打开操作写好关闭语句
if !isValid {
fmt.Println("[中止] 校验未通过,提前返回")
return
}
fmt.Println("[处理] 正常读取并处理数据")
}
func main() {
readData(false)
fmt.Println("---")
readData(true)
}运行结果如下。
[打开] 打开文件资源
[中止] 校验未通过,提前返回
[关闭] 关闭文件资源
---
[打开] 打开文件资源
[处理] 正常读取并处理数据
[关闭] 关闭文件资源分析:
在 readData() 函数中,我们在打开资源后紧接着就在下一行写上了 defer 关闭操作。把 “打开” 和 “关闭” 两行代码紧挨着放在一起,逻辑直观,不容易遗漏关闭步骤。
从两次调用的结果可以看出:当我们第 1 次传入 false 时,函数在 if 分支遇到 return 提前退出。当我们第 2 次传入 true 时,函数正常执行到最后一行结束。无论走哪一条路径,defer 关闭语句都会在函数退出前自动执行,确保资源正常释放。
结合第 1 节提到的规则,实际开发时还有一个高频大坑,小伙伴们一定要提前避开:千万不要直接在 for 循环内部使用 defer 来关闭文件或网络连接。
因为 defer 要等到当前整个函数结束时才统一执行。如果循环里依次打开了 1000 个文件,这些资源就会一直占着不释放,全部积压到函数退出那一刻,很容易把系统资源耗尽。
想要解决这个问题其实非常简单:我们可以把单次循环里的 “打开、处理、defer 关闭” 封装成一个独立的小函数,也可以用立即执行匿名函数包一层。这样每跑完一轮循环,小函数一结束就能立刻释放当次资源。
// 不推荐
for _, name := range files {
openFile(name)
defer closeFile(name)
}
// 推荐
for _, name := range files {
processFile(name) // 在函数内部 defer 关闭
}养成 “打开资源就紧跟 defer,循环处理就抽成小函数” 的习惯,后面编写文件操作和网络代码时会省心很多。
