Go语言错误处理：核心模式与最佳实践

package main

import (
    "fmt"
    "os"
)

func readFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        // 错误发生，返回错误
        return nil, fmt.Errorf("读取文件 %s 失败: %w", filename, err)
    }
    return data, nil
}

func main() {
    // 尝试读取一个不存在的文件
    data, err := readFile("non_existent_file.txt")
    if err != nil {
        fmt.Printf("主程序处理错误: %v\n", err)
        return
    }
    fmt.Printf("文件内容: %s\n", string(data))

    // 尝试读取一个存在的文件（假设存在）
    data, err = readFile("existent_file.txt") // 假设这个文件存在且可读
    if err != nil {
        fmt.Printf("主程序处理错误: %v\n", err)
        return
    }
    fmt.Printf("文件内容: %s\n", string(data))
}

func processData(input string) (string, error) {
    // 假设这里可能发生错误
    result, err := someOperation(input)
    if err != nil {
        return "", fmt.Errorf("处理数据失败: %w", err) // 包装错误并返回
    }
    return result, nil
}

import "log"

func doSomething() {
    err := performRiskyOperation()
    if err != nil {
        log.Printf("执行风险操作失败: %v", err) // 记录错误，但程序可能继续执行
        // 也可以选择返回错误，这取决于业务逻辑
    }
    // ...
}

package main

import (
    "errors"
    "fmt"
)

var ErrInvalidInput = errors.New("无效输入")

func validateInput(input string) error {
    if len(input) == 0 {
        return ErrInvalidInput
    }
    return nil
}

func processRequest(data string) error {
    err := validateInput(data)
    if err != nil {
        // 使用 %w 包装原始错误，添加上下文
        return fmt.Errorf("处理请求时验证输入失败: %w", err)
    }
    return nil
}

func main() {
    err := processRequest("")
    if err != nil {
        fmt.Printf("收到的错误: %v\n", err) // 打印完整的错误链
        // 使用 errors.Is 检查错误链中是否包含特定错误
        if errors.Is(err, ErrInvalidInput) {
            fmt.Println("这是一个无效输入错误。")
        }

        // 使用 errors.As 获取特定类型的错误（如果错误是自定义类型）
        var target *MyCustomError
        if errors.As(err, &target) {
            fmt.Printf("错误是 MyCustomError 类型，错误码: %d\n", target.Code)
        }
    }
}

// 示例自定义错误类型
type MyCustomError struct {
    Code    int
    Message string
}

func (e *MyCustomError) Error() string {
    return fmt.Sprintf("自定义错误码 %d: %s", e.Code, e.Message)
}

package main

import "fmt"

type CustomError struct {
    Code    int
    Message string
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("错误码 %d: %s", e.Code, e.Message)
}

func doSomethingWithError() error {
    // 返回一个自定义错误
    return &CustomError{Code: 1001, Message: "操作失败，原因未知"}
}

func main() {
    err := doSomethingWithError()
    if err != nil {
        fmt.Printf("捕获到错误: %v\n", err)
        // 类型断言，判断是否是自定义错误类型
        if ce, ok := err.(*CustomError); ok {
            fmt.Printf("这是一个自定义错误，错误码: %d\n", ce.Code)
        }
    }
}

package main

import "fmt"

func mightPanic() {
    // 这是一个会引起 panic 的操作
    var s []int
    fmt.Println(s[0]) // 索引越界，会 panic
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("程序从 panic 中恢复: %v\n", r)
        }
    }()

    fmt.Println("尝试执行可能引起 panic 的函数...")
    mightPanic()
    fmt.Println("此行代码不会被执行，因为 panic 发生了。") // 这行不会被打印
}