深入理解Go语言panic与recover：在defer中捕获并转化错误

package main

import (
    "errors"
    "fmt"
    "runtime" // 用于获取运行时错误信息
)

// A 函数调用 B 函数，并使用 defer-recover 机制捕获 B 可能抛出的 panic
func A(s string) (result string, err error) {
    // defer 函数在 A 返回前执行，用于捕获 panic
    defer func() {
        if r := recover(); r != nil { // recover() 捕获 panic 抛出的值
            // 根据 panic 值的类型进行处理，统一转化为 error 类型
            switch x := r.(type) {
            case error:
                err = x // 如果 panic 抛出的是 error 类型，直接赋值
            case string:
                err = errors.New(x) // 如果是字符串，创建新的 error
            case int:
                err = fmt.Errorf("panic with int value: %d", x) // 如果是整数，格式化为 error
            default:
                // 处理其他未知类型，例如运行时错误
                // runtime.Error 是一个接口，代表 Go 运行时错误
                if rErr, ok := x.(runtime.Error); ok {
                    err = rErr
                } else {
                    err = fmt.Errorf("unknown panic type: %v", x)
                }
            }
            // 在这里可以对 err 进行进一步处理，例如记录日志或发送到错误报告系统
            fmt.Printf("Recovered from panic: %v\n", err)
        }
    }()

    // 调用可能 panic 的函数 B
    B(s)
    return "returned successfully", nil
}

// B 函数根据输入参数 s 决定是否触发 panic，并抛出不同类型的值
func B(s string) {
    switch s {
    case "ok":
        fmt.Println("B: Operation successful.")
        return
    case "fail_with_error":
        fmt.Println("B: Panicking with an error...")
        panic(errors.New("operation failed due to invalid data")) // 抛出 error 类型
    case "fail_with_int":
        fmt.Println("B: Panicking with an integer...")
        panic(42) // 抛出 int 类型
    case "fail_with_string":
        fmt.Println("B: Panicking with a string...")
        panic("critical failure occurred") // 抛出 string 类型
    case "fail_with_runtime_error":
        fmt.Println("B: Panicking with a runtime error (division by zero)...")
        a, b := 1, 0
        // 故意制造一个运行时错误，它会触发 panic
        _ = a / b // 触发除以零 panic
    default:
        fmt.Println("B: Unknown case, panicking with default string...")
        panic("unhandled case in B")
    }
}

func main() {
    // 正常执行情况
    s, err := A("ok")
    fmt.Printf("A(\"ok\"): result=%q, err=%v\n\n", s, err)

    // 捕获 error 类型的 panic
    s, err = A("fail_with_error")
    fmt.Printf("A(\"fail_with_error\"): result=%q, err=%v\n\n", s, err)

    // 捕获 int 类型的 panic
    s, err = A("fail_with_int")
    fmt.Printf("A(\"fail_with_int\"): result=%q, err=%v\n\n", s, err)

    // 捕获 string 类型的 panic
    s, err = A("fail_with_string")
    fmt.Printf("A(\"fail_with_string\"): result=%q, err=%v\n\n", s, err)

    // 捕获运行时错误 (runtime.Error) 类型的 panic
    s, err = A("fail_with_runtime_error")
    fmt.Printf("A(\"fail_with_runtime_error\"): result=%q, err=%v\n\n", s, err)
}

B: Operation successful.
A("ok"): result="returned successfully", err=<nil>

B: Panicking with an error...
Recovered from panic: operation failed due to invalid data
A("fail_with_error"): result="", err=operation failed due to invalid data

B: Panicking with an integer...
Recovered from panic: panic with int value: 42
A("fail_with_int"): result="", err=panic with int value: 42

B: Panicking with a string...
Recovered from panic: critical failure occurred
A("fail_with_string"): result="", err=critical failure occurred

B: Panicking with a runtime error (division by zero)...
Recovered from panic: runtime error: integer divide by zero
A("fail_with_runtime_error"): result="", err=runtime error: integer divide by zero