Go 语言 defer 语句概览
在 go 语言中，defer 语句用于延迟函数的执行，直到包含 defer 语句的函数即将返回。这在资源清理（如关闭文件、解锁互斥锁）或记录日志等场景中非常有用，可以确保清理操作无论函数如何退出（正常返回或发生 panic）都能被执行。
defer 语句的执行顺序遵循“后进先出”（LIFO）原则。即，在同一个函数中，最后被 defer 的函数会最先执行，而最先被 defer 的函数会最后执行。
示例代码分析
为了更好地理解 defer 与闭包中的变量捕获，我们来看一个具体的 Go 代码示例：
package main
import "fmt"
func main() {
var whatever [5]struct{}
// Part 1: 基础循环，直接打印 i
for i := range whatever {
fmt.Println(i)
}
// Part 2: 在循环中使用 defer 结合闭包，直接捕获 i
for i := range whatever {
defer func() { fmt.Println(i) }()
}
// Part 3: 在循环中使用 defer 结合闭包，将 i 作为参数传递
for i := range whatever {
defer func(n int) { fmt.Println(n) }(i)
}
}这段代码的输出结果是：01234444443210。 其中，01234 是 Part 1 的输出，44444 是 Part 2 的输出，43210 是 Part 3 的输出。 接下来，我们将详细分析 Part 2 和 Part 3 的行为差异。
闭包的变量捕获陷阱：Part 2 解析
在 Part 2 中，我们使用了 defer func() { fmt.Println(i) }() 这种形式。这里的匿名函数是一个闭包，它捕获了外部作用域的变量 i。
for i := range whatever {
defer func() { fmt.Println(i) }() // 闭包捕获外部变量 i
}关键点在于： 闭包捕获的是变量 i 的“引用”，而不是 i 在每次迭代时的“值”。当 main 函数执行到 defer 语句时，它将这个匿名函数推入延迟调用栈。然而，这个匿名函数并不会立即执行，而是等待 main 函数返回前才执行。
当 main 函数最终返回时，for 循环已经完全执行完毕。此时，循环变量 i 的最终值是 4（因为 whatever 数组有 5 个元素，range 会迭代 0 到 4）。由于所有被延迟的闭包都共享同一个 i 变量的引用，它们在执行时都会去读取 i 的当前值，即最终值 4。
因此，Part 2 的输出是 44444。这是一个常见的陷阱，因为开发者可能预期它会打印 01234 或 43210。
正确处理循环中的 defer 与闭包：Part 3 解析
与 Part 2 不同，Part 3 使用了 defer func(n int) { fmt.Println(n) }(i) 这种形式。这里，我们将循环变量 i 作为参数显式地传递给了匿名函数。
for i := range whatever {
defer func(n int) { fmt.Println(n) }(i) // i 的值作为参数 n 传递
}关键点在于： Go 语言规范明确指出，当 defer 语句执行时，其函数值和参数都会被“立即求值并保存”。这意味着在每次循环迭代中：
- i 的当前值（例如，在第一次迭代中是 0，第二次是 1，以此类推）会被立即求值。
- 这个求得的值会作为参数 n 传递给匿名函数，并为该匿名函数创建一个独立的副本。
- 这个带有独立 n 值的匿名函数被推入延迟调用栈。
因此，每次 defer 语句执行时，它都保存了 i 在那一刻的“值”。当 main 函数返回时，这些延迟函数会按照 LIFO 顺序执行：
- 最后被 defer 的函数（i 为 4 时）会最先执行，打印 4。
- 倒数第二个被 defer 的函数（i 为 3 时）会接着执行，打印 3。
- 以此类推，直到第一个被 defer 的函数（i 为 0 时）最后执行，打印 0。
所以，Part 3 的输出是 43210。
核心区别与最佳实践
Part 2 和 Part 3 的行为差异揭示了 defer 语句与闭包在变量处理上的核心机制：
- 闭包捕获外部变量（Part 2）： 闭包会捕获其定义时外部作用域中变量的引用。这意味着当闭包最终执行时，它会读取该变量的当前值，这可能是循环结束后变量的最终值。
- defer 参数立即求值（Part 3）： defer 语句在执行时，其函数参数会立即求值。这意味着如果将循环变量作为参数传递给延迟函数，那么在每次迭代中，该变量的当前值会被复制并作为参数保存起来，与循环结束后变量的最终值无关。
Go 语言规范原文强调：
Each time the "defer" statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked. (每次 "defer" 语句执行时，函数值和参数都会像往常一样被求值并重新保存，但实际函数不会被调用。)
避免陷阱的最佳实践：
在循环中使用 defer 结合闭包时，如果需要捕获循环变量在当前迭代中的值，而不是循环结束后的最终值，有两种常用方法：
-
将变量作为参数传递给闭包（如 Part 3 所示）：
for i := range whatever { defer func(n int) { fmt.Println(n) }(i) } -
在循环内部创建变量的局部副本：
for i := range whatever { localI := i // 创建 i 的局部副本 defer func() { fmt.Println(localI) }() }这种方法同样有效，因为每次迭代都会创建一个新的 localI 变量，闭包捕获的是这个局部变量的引用，而这个局部变量在每次迭代中都保存了 i 当时的值。最终效果与将 i 作为参数传递相同，输出也是 43210。
总结
理解 Go 语言中 defer 语句的 LIFO 执行顺序以及闭包变量捕获的机制至关重要。尤其是在循环中，明确变量是按引用捕获还是按值传递作为参数，能够帮助开发者避免常见的逻辑错误。通过将循环变量作为参数传递给延迟函数，或者创建其局部副本，可以确保 defer 语句的行为符合预期，从而编写出更加健壮和可预测的 Go 程序。
