从基础到高级详解Go语言中错误处理的实践指南

type error interface {
    Error() string
}

// 使用 errors.New 创建简单错误
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// 使用 fmt.Errorf 创建格式化错误
func calculate(a, b int) (int, error) {
    if a < 0 || b < 0 {
        return 0, fmt.Errorf("参数不能为负数：a=%d, b=%d", a, b)
    }
    return a + b, nil
}

result, err := divide(10, 0)
if err != nil {
    // 处理错误
    fmt.Println("错误：", err.Error())
    return
}
// 使用结果
fmt.Println("结果：", result)

func process() error {
    err := firstStep()
    if err != nil {
        return fmt.Errorf("处理失败：%w", err) // 使用 %w 包装错误
    }
    return nil
}

func firstStep() error {
    return errors.New("第一步错误")
}

err := process()

// 使用 errors.Unwrap 解链错误
for e := err; e != nil; e = errors.Unwrap(e) {
    fmt.Println("错误：", e)
}

// 使用 errors.Is 检查特定错误
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("文件不存在错误")
}

// 使用 errors.As 提取特定错误类型
var dbErr *DatabaseError
if errors.As(err, &dbErr) {
    fmt.Println("数据库错误代码：", dbErr.Code)
}

// 定义自定义错误结构体
type ValidationError struct {
    Field   string
    Msg     string
    Code    int
}

// 实现 Error() 方法
func (e *ValidationError) Error() string {
    return fmt.Sprintf("字段 %s 错误：%s (代码%d)", e.Field, e.Msg, e.Code)
}

// 使用自定义错误
func validateUser(user string) error {
    if user == "" {
        return &ValidationError{
            Field: "user", 
            Msg: "不能为空",
            Code: 400
        }
    }
    return nil
}

// 在真正不可恢复的情况下使用 panic
func mustLoadConfig(path string) *Config {
    data, err := os.ReadFile(path)
    if err != nil {
        panic(fmt.Sprintf("加载配置文件失败: %v", err))
    }
    // 解析配置...
    return config
}

func safeRun() (err error) {
    defer func() {
        if r := recover(); r != nil {
            // 将 panic 转换为 error 返回
            err = fmt.Errorf("panic recovered: %v", r)
        }
    }()
    
    // 可能触发 panic 的代码
    dangerousOperation()
    
    return nil
}

// 反模式1：忽略错误
data, _ := os.ReadFile("data.txt") // 危险！错误被忽略

// 反模式2：过度包装错误
return fmt.Errorf("包装错误：%w", fmt.Errorf("再次包装：%w", err)) // 冗余包装

// 反模式3：滥用 panic 处理可恢复错误
func wrongUseOfPanic(user string) {
    if user == "" {
        panic("用户为空") // 应返回 error 而非 panic
    }
}