Golangdefer多次调用执行顺序解析-Golang-PHP中文网

Golangdefer多次调用执行顺序解析

P粉602998670

发布： 2025-09-17 09:15:01

原创

183人浏览过

defer语句按后进先出（LIFO）顺序执行，其参数在定义时即求值。1. 每次defer将函数及其参数压栈；2. 函数返回时，栈中defer按逆序执行；3. 参数在defer语句执行时快照，而非实际调用时；4. 循环中defer不立即执行，而是函数退出时统一按LIFO执行；5. 结合闭包可正确捕获循环变量，避免资源关闭错误；6. defer用于确保资源释放和错误处理的可靠性，提升代码健壮性。

golangdefer多次调用执行顺序解析

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

登录后复制

打印的是

登录后复制

，

Defer 2

登录后复制

打印的是

登录后复制

，尽管在函数内部的

fmt.Println

登录后复制

执行时

登录后复制

的值已经是

登录后复制

。这是因为

登录后复制

的值在每个

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

登录后复制

语句在循环中每次迭代都会被执行，并将一个匿名函数（捕获了当前迭代的

登录后复制

）推入栈中。当

createAndCloseFiles

登录后复制

函数最终返回时，这些

defer

登录后复制

才开始按LIFO顺序执行。

file3.txt

登录后复制

的关闭语句是最后一个被

defer

登录后复制

的，所以它最先执行；

file1.txt

登录后复制

是第一个被

defer

登录后复制

的，所以它最后执行。

这里有一个非常重要的点：如果

登录后复制

没有作为参数传递给匿名函数，而是直接在匿名函数体中引用循环变量

登录后复制

，那么所有的

defer

登录后复制

都会引用循环结束时

登录后复制

的最终值（即最后一个成功创建的文件），这会导致所有

defer

登录后复制

都尝试关闭同一个文件，或者导致错误。通过

defer func(file *os.File) { ... }(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
    }

登录后复制

以上就是Golangdefer多次调用执行顺序解析的详细内容，更多请关注php中文网其它相关文章！