Go语言中defer关键字的作用域深度解析与跨函数延迟执行模式

package main

import "fmt"

func exampleDefer() {
    fmt.Println("开始执行 exampleDefer")
    defer fmt.Println("这是 defer 语句，将在函数返回前执行")
    fmt.Println("exampleDefer 正在执行中...")
}

func main() {
    exampleDefer()
    fmt.Println("main 函数执行完毕")
}

开始执行 exampleDefer
exampleDefer 正在执行中...
这是 defer 语句，将在函数返回前执行
main 函数执行完毕

package main

import "fmt"

// 模拟数据库连接和事务
type Db struct{}

func (db Db) Begin() {
    fmt.Println("事务开始")
}

func (db Db) Commit() {
    fmt.Println("事务提交")
}

// 示例1: 正常事务处理
func dbStuffNormal() {
    db := Db{}
    db.Begin()
    fmt.Println("执行一些数据库操作...")
    db.Commit()
}

// 示例2: 使用 defer 进行事务提交 (作用于 dbStuffDefer 函数本身)
func dbStuffDefer() {
    db := Db{}
    db.Begin()
    defer db.Commit() // 此 defer 作用于 dbStuffDefer 函数
    fmt.Println("执行一些数据库操作...")
}

// 示例3: 尝试在内部函数中 defer 到外部函数 (错误理解)
func (db Db) Trans() {
    db.Begin()
    defer db.Commit() // !! 注意：此 defer 作用于 Trans() 函数，而非其调用者
    fmt.Println("Trans() 函数内部执行一些操作...")
}

func dbStuffWithTrans() {
    db := Db{}
    db.Trans() // 调用 Trans()
    fmt.Println("dbStuffWithTrans() 函数内部执行一些操作...")
}

func main() {
    fmt.Println("--- dbStuffNormal ---")
    dbStuffNormal()
    fmt.Println("\n--- dbStuffDefer ---")
    dbStuffDefer()
    fmt.Println("\n--- dbStuffWithTrans ---")
    dbStuffWithTrans()
}

--- dbStuffWithTrans ---
事务开始
Trans() 函数内部执行一些操作...
事务提交
dbStuffWithTrans() 函数内部执行一些操作...

package main

import "fmt"

// greet 函数返回一个匿名函数
func greet() func() {
    fmt.Println("Hello!") // greet 函数体内的代码会立即执行
    // 返回的匿名函数将在被 defer 后，于调用者函数返回时执行
    return func() { fmt.Println("Bye!") }
}

func main() {
    fmt.Println("main 函数开始")
    // defer greet()() 的执行过程：
    // 1. 调用 greet()。此时 "Hello!" 被打印。
    // 2. greet() 返回一个 func() 类型的匿名函数。
    // 3. 这个返回的匿名函数被 defer 调度。
    // 4. main 函数继续执行。
    // 5. main 函数即将返回时，被 defer 调度的匿名函数执行，打印 "Bye!"。
    defer greet()()
    fmt.Println("main 函数中的其他代码...")
    fmt.Println("main 函数结束")
}

main 函数开始
Hello!
main 函数中的其他代码...
main 函数结束
Bye!

package main

import "fmt"

type Tx struct {
    // 事务相关状态，例如数据库连接
    committed bool
}

func (tx *Tx) Commit() {
    if !tx.committed {
        fmt.Println("事务提交成功！")
        tx.committed = true
    }
}

func (tx *Tx) Rollback() {
    if !tx.committed {
        fmt.Println("事务回滚！")
    }
}

// BeginTx 启动一个事务，并返回一个事务对象
func BeginTx() *Tx {
    fmt.Println("数据库事务开始...")
    tx := &Tx{} // 模拟创建事务对象
    return tx
}

// DeferrableCommit 创建一个闭包，用于在外部函数返回时提交事务
// 实际应用中，通常会返回一个 error，并在 defer 中根据 error 判断是 Commit 还是 Rollback
func DeferrableCommit(tx *Tx) func() {
    return func() {
        // 这里的逻辑将在调用者函数返回时执行
        // 可以在这里根据事务状态或错误信息决定是提交还是回滚
        tx.Commit() // 简化示例，直接提交
    }
}

func dbStuffWithDeferrableCommit() {
    tx := BeginTx() // 事务开始，并获取事务对象
    // defer DeferrableCommit(tx)() 将会在 dbStuffWithDeferrableCommit 函数返回时执行 tx.Commit()
    defer DeferrableCommit(tx)()

    fmt.Println("dbStuffWithDeferrableCommit 正在执行业务逻辑...")
    // 假设这里发生错误，可能需要 Rollback
    // if someError != nil {
    //     tx.Rollback()
    //     return
    // }
}

func main() {
    fmt.Println("--- dbStuffWithDeferrableCommit ---")
    dbStuffWithDeferrableCommit()
    fmt.Println("main 函数结束，所有事务处理完毕。")
}

--- dbStuffWithDeferrableCommit ---
数据库事务开始...
db