defer语句按后进先出（LIFO）顺序执行，其参数在定义时即求值。1. 每次defer将函数及其参数压栈；2. 函数返回时，栈中defer按逆序执行；3. 参数在defer语句执行时快照，而非实际调用时；4. 循环中defer不立即执行，而是函数退出时统一按LIFO执行；5. 结合闭包可正确捕获循环变量，避免资源关闭错误；6. defer用于确保资源释放和错误处理的可靠性，提升代码健壮性。
defer语句的执行顺序是后进先出（LIFO），并且其参数在
defer语句被定义时就已经求值了。这意味着，无论你调用多少次
defer，它们都会在函数即将返回时，以与定义时相反的顺序依次执行。
当我们在Go语言中谈论
defer，特别是当一个函数内部多次调用
defer时，需要建立一个基于栈（Stack）的思维模型。每次遇到
defer语句，它都会将要执行的函数调用（以及它当时就已经求值完毕的参数）压入一个栈中。这个栈并非只是一个概念，它精确地决定了这些被延迟执行的调用在函数退出时的执行顺序。
想象一下，你正在堆叠一摞盘子。每当你
defer一个操作，就相当于将一个新盘子放在最上面。当函数完成其任务，无论是通过
return语句正常返回，执行到函数体的末尾，还是因为
panic而异常退出，这些盘子都会从最上面一个接一个地取走，并执行它们各自的操作。这种“最上层优先”的取出方式，正是“后进先出”（LIFO）原则的体现。
我们通过一个实际的例子来进一步说明这一点。
立即学习“go语言免费学习笔记（深入）”；
package main
import "fmt"
func demonstrateDeferOrder() {
fmt.Println("函数开始执行。")
defer fmt.Println("Defer 1: 这个会最后执行。")
defer fmt.Println("Defer 2: 这个会倒数第二个执行。")
defer fmt.Println("Defer 3: 这个会最先执行（在所有defer中）。")
fmt.Println("函数正在进行一些工作。")
}
func main() {
demonstrateDeferOrder()
}运行这段代码，你会看到这样的输出：
函数开始执行。 函数正在进行一些工作。 Defer 3: 这个会最先执行（在所有defer中）。 Defer 2: 这个会倒数第二个执行。 Defer 1: 这个会最后执行。
从输出中可以清楚地看到，
Defer 1是第一个被
defer的，接着是
Defer 2，最后是
Defer 3。当
demonstrateDeferOrder函数退出时，
Defer 3（最后一个被压入栈的）最先执行，然后是
Defer 2，最后是
Defer 1（第一个被压入栈的）。这完美地展示了LIFO原则。
此外，一个经常被忽视但至关重要的细节是：被
defer的函数的参数是在
defer语句被执行时就立即求值的，而不是在被延迟的函数真正执行时。如果对此不清楚，可能会导致一些出人意料的结果。
再看一个例子：
package main
import "fmt"
func demonstrateDeferWithArgs() {
i := 0
defer fmt.Println("Defer 1 (i在defer时):", i) // i在这里被捕获为 0
i++ // i 变为 1
defer fmt.Println("Defer 2 (i在defer时):", i) // i在这里被捕获为 1
i++ // i 变为 2
fmt.Println("函数内部，i的值是:", i)
}
func main() {
demonstrateDeferWithArgs()
}这段代码的输出将会是：
Shell脚本编写基础 中文WORD版
下载
Shell本身是一个用C语言编写的程序，它是用户使用Linux的桥梁。Shell既是一种命令语言，又是一种程序设计语言。作为命令语言，它交互式地解释和执行用户输入的命令；作为程序设计语言，它定义了各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。它虽然不是Linux系统核心的一部分，但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此，对于用户来说，shell是最重要的实用程序，深入了解和熟练掌握shell的特性极其使用方法，是用好Linux系统
函数内部，i的值是: 2 Defer 2 (i在defer时): 1 Defer 1 (i在defer时): 0
可以看到，
Defer 1打印的是
0，
Defer 2打印的是
1，尽管在函数内部的
fmt.Println执行时
i的值已经是
2。这是因为
i的值在每个
defer语句被遇到并注册时就已经被“快照”下来了。理解这种行为对于正确使用
defer，尤其是在循环或处理共享变量时，是至关重要的，可以帮助我们避免常见的陷阱。
defer
在循环中如何表现？
在循环中使用
defer是一个经典的场景，也最容易让人产生误解。
defer是绑定到其所在的整个函数退出时执行的，而不是循环的每一次迭代结束时。这意味着，如果你在一个循环内部多次调用
defer，所有的
defer语句都会被推入栈中，但它们只会在包含该循环的整个函数退出时才开始执行，并且同样遵循LIFO原则。
我们来看一个常见的资源清理场景：
package main
import (
"fmt"
"os"
)
func createAndCloseFiles() {
files := []string{"file1.txt", "file2.txt", "file3.txt"}
for _, filename := range files {
f, err := os.Create(filename)
if err != nil {
fmt.Printf("创建文件 %s 失败: %v\n", filename, err)
continue
}
fmt.Printf("已创建文件 %s\n", filename)
// 这里的defer会在函数createAndCloseFiles退出时才执行
// f的值在defer定义时被捕获，确保每次迭代关闭的是正确的文件
defer func(file *os.File) {
fmt.Printf("正在关闭文件 %s\n", file.Name())
file.Close()
}(f)
}
fmt.Println("所有文件已创建。函数继续执行其他工作...")
}
func main() {
createAndCloseFiles()
fmt.Println("函数 createAndCloseFiles 执行完毕。")
// 实际应用中，这里可能会检查文件是否已被正确关闭
// os.Remove("file1.txt") // 演示完成后可以手动清理
}运行这段代码，你会看到这样的输出：
已创建文件 file1.txt 已创建文件 file2.txt 已创建文件 file3.txt 所有文件已创建。函数继续执行其他工作... 正在关闭文件 file3.txt 正在关闭文件 file2.txt 正在关闭文件 file1.txt 函数 createAndCloseFiles 执行完毕。
很明显，
defer语句在循环中每次迭代都会被执行，并将一个匿名函数（捕获了当前迭代的
f）推入栈中。当
createAndCloseFiles函数最终返回时，这些
defer才开始按LIFO顺序执行。
file3.txt的关闭语句是最后一个被
defer的，所以它最先执行；
file1.txt是第一个被
defer的，所以它最后执行。
这里有一个非常重要的点：如果
f没有作为参数传递给匿名函数，而是直接在匿名函数体中引用循环变量
f，那么所有的
defer都会引用循环结束时
f的最终值（即最后一个成功创建的文件），这会导致所有
defer都尝试关闭同一个文件，或者导致错误。通过
defer func(file *os.File) { ... }(f) 这种方式，我们确保了每次迭代的f都被正确地捕获，这是Go闭包的一个关键特性。
defer
与错误处理及资源清理的结合
defer的设计初衷之一就是简化资源管理和错误处理。它提供了一种简洁、可靠的方式来确保无论函数如何退出（正常返回、提前返回、甚至发生panic），某些清理操作都能被执行。这极大地减少了代码的重复性，并提高了程序的健壮性。
想象一下，你需要打开一个文件，写入一些内容，然后关闭它。如果写入过程中发生错误，你仍然需要关闭文件。没有
defer，代码可能看起来像这样：
func processFileWithoutDefer(filename string, content []byte) error {
f, err := os.Create(filename)
if err != nil {
return err
}
_, err = f.Write(content)
if err != nil {
f.Close() // 错误时手动关闭
return err
} 
