Go语言中defer与panic的错误处理：从panic中优雅返回错误

func someFunction() (result string, err error) {
    // ...
    defer func() {
        // 在这里可以访问并修改 result 和 err
        if err != nil {
            fmt.Printf("发生错误: %v\n", err)
        }
    }()
    // ...
    return "成功", nil
}

defer func() {
    if r := recover(); r != nil {
        // ...
        return nil, err // 错误：不能在defer中改变外部函数的返回流
    }
}()

package main

import (
    "errors"
    "fmt"
)

// 假设这是一个报告结构体
type report struct {
    data map[string]float64
}

// getReport 尝试生成一个报告，但在特定情况下会panic
func getReport(filename string) (rep report, err error) {
    // 初始化报告，如果后续发生panic，可能需要将其置空
    rep.data = make(map[string]float64)

    // 使用defer和recover来捕获panic并转换为错误
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("在getReport中捕获到panic: %v\n", r)
            // 根据panic值的类型进行处理，并将其转换为error
            switch x := r.(type) {
            case string:
                err = errors.New(x) // 如果panic是字符串，包装为error
            case error:
                err = x // 如果panic本身就是error类型，直接赋值
            default:
                err = fmt.Errorf("未知类型的panic: %v", x) // 处理其他未知类型
            }
            // 如果发生panic，报告数据可能不完整或无效，将其置为零值
            rep = report{} // 或者 rep = nil，取决于rep的类型和预期行为
        }
    }()

    // 模拟可能导致panic的代码
    if filename == "invalid.txt" {
        panic("报告格式无法识别：无效的文件名") // 使用字符串进行panic
    }
    if filename == "critical_error.txt" {
        panic(errors.New("关键系统错误：无法读取数据")) // 使用error进行panic
    }

    // 假设这里是正常的报告生成逻辑
    rep.data["metric1"] = 10.5
    rep.data["metric2"] = 20.3

    return rep, nil // 正常返回
}

func main() {
    // 正常情况
    r1, e1 := getReport("valid.txt")
    if e1 != nil {
        fmt.Printf("处理 valid.txt 时发生错误: %v\n", e1)
    } else {
        fmt.Printf("成功生成报告 (valid.txt): %v\n", r1)
    }

    fmt.Println("---")

    // 模拟字符串panic
    r2, e2 := getReport("invalid.txt")
    if e2 != nil {
        fmt.Printf("处理 invalid.txt 时发生错误: %v\n", e2)
    } else {
        fmt.Printf("成功生成报告 (invalid.txt): %v\n", r2)
    }

    fmt.Println("---")

    // 模拟error panic
    r3, e3 := getReport("critical_error.txt")
    if e3 != nil {
        fmt.Printf("处理 critical_error.txt 时发生错误: %v\n", e3)
    } else {
        fmt.Printf("成功生成报告 (critical_error.txt): %v\n", r3)
    }

    fmt.Println("---")

    // 模拟未知类型panic (例如，整数)
    func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("在匿名函数中捕获到panic: %v\n", r)
                // 这里的err是匿名函数的，如果需要传递出去，需要更复杂的机制
                // 但主要演示了recover如何捕获不同类型
                switch x := r.(type) {
                case string:
                    fmt.Printf("Recovered string: %s\n", x)
                case error:
                    fmt.Printf("Recovered error: %v\n", x)
                default:
                    fmt.Printf("Recovered unknown type: %v\n", x)
                }
            }
        }()
        panic(123) // 模拟一个整数panic
    }()
}