Go语言中panic(nil)的检测与处理：从旧有陷阱到Go 1.21的新机制

package main

import "fmt"

func doTransaction() error {
    // 模拟一个可能 panic(nil) 的操作
    // panic(nil) // 如果这里 panic(nil)
    fmt.Println("Transaction logic executing...")
    return nil
}

func main() {
    defer func() {
        var r = recover()
        if r != nil {
            // 此处通常用于处理真正的恐慌情况，例如回滚事务
            // 但对于 panic(nil)，此分支不会被执行
            fmt.Printf("Recovered from panic: %v\n", r)
            fmt.Println("Executing critical cleanup (e.g., rollback).")
        } else {
            fmt.Println("No panic occurred, or panic(nil) was not caught by r != nil.")
        }
    }()

    // 模拟业务逻辑
    // 如果 doTransaction() 内部调用了 panic(nil)，
    // 上述 defer 中的 r != nil 将不会捕获到它。
    err := doTransaction()
    if err == nil {
        fmt.Println("Transaction committed successfully.")
    } else {
        fmt.Printf("Transaction failed with error: %v\n", err)
        fmt.Println("Executing regular error rollback.")
    }
    // 再次模拟 panic(nil) 看看效果
    // panic(nil)
}

package main

import "fmt"

func performOperation() (err error) {
    panicked := true // 初始假设可能会发生恐慌
    defer func() {
        if panicked {
            // 如果 panicked 仍为 true，说明函数没有正常退出
            // 此时 recover() 的返回值无论是否为 nil，都表明发生了恐慌
            r := recover()
            if r != nil {
                // 处理非 nil 的恐慌值
                fmt.Printf("Recovered from panic: %v\n", r)
            } else {
                // 处理 panic(nil) 情况
                fmt.Println("Recovered from panic(nil) using flag workaround.")
            }
            // 执行关键清理操作
            fmt.Println("Executing critical cleanup after any panic.")
        } else {
            fmt.Println("Function exited normally, no panic cleanup needed.")
        }
    }()

    fmt.Println("Attempting a risky operation...")
    // 模拟 panic(nil)
    // panic(nil) 
    // 模拟其他 panic
    // panic("something went wrong") 

    // 正常退出前，将 panicked 设为 false
    panicked = false
    fmt.Println("Operation completed successfully.")
    return nil // 正常返回
}

func main() {
    performOperation()
    fmt.Println("Program continues after operation.")

    fmt.Println("\n--- Testing with panic(nil) ---")
    func() {
        panicked := true
        defer func() {
            if panicked {
                r := recover()
                if r != nil {
                    fmt.Printf("Recovered from panic: %v\n", r)
                } else {
                    fmt.Println("Recovered from panic(nil) in anonymous func.")
                }
                fmt.Println("Cleanup for panic(nil) executed.")
            }
        }()
        panic(nil) // 模拟 panic(nil)
        panicked = false // 不会被执行
    }()
    fmt.Println("After anonymous func with panic(nil).")
}

package main

import (
    "fmt"
    // "runtime" // runtime.PanicNil 是内部类型，通常不需要直接导入
)

func doSomethingDangerous() {
    defer func() {
        if r := recover(); r != nil {
            // 在 Go 1.21+ (且 go.mod 声明 go 1.21) 中，
            // 无论 panic 的值是什么（包括 nil），r 都不会是 nil。
            // 如果需要区分 panic(nil) 和其他 panic，可以进一步检查 r 的类型。
            // 例如：_, isNilPanic := r.(*runtime.PanicNil)
            fmt.Printf("Recovered from panic: %v\n", r)
            fmt.Println("Executing critical cleanup after any panic (Go 1.21+).")
        } else {
            fmt.Println("No panic occurred.")
        }
    }()

    fmt.Println("Attempting a risky operation...")
    // 模拟 panic(nil)