Golang错误类型处理与自定义方法

Go通过error接口实现错误处理，使用errors.New和fmt.Errorf创建错误，支持自定义错误类型、哨兵错误及错误包装。

在Go语言中，错误处理是程序设计的重要组成部分。Go通过内置的error接口来表示错误，其定义非常简单：

type error interface {
    Error() string
}

任何实现了Error()方法的类型都可以作为错误使用。Go标准库中的errors.New和fmt.Errorf是最常用的创建错误的方式。

基本错误创建与判断

使用errors.New可以快速创建一个简单的错误：

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err.Error())
        // 输出: Error: division by zero
    }
    fmt.Println(result)
}

你也可以用fmt.Errorf格式化生成错误信息：

if b == 0 {
    return 0, fmt.Errorf("cannot divide %f by zero", a)
}

自定义错误类型

当需要携带更多上下文信息时，可以定义自己的错误类型。例如，记录操作、时间或状态码：

type MathError struct {
    Op       string  // 操作类型
    Operand  float64 // 出错的操作数
    Message  string  // 错误描述
}

func (e *MathError) Error() string {
    return fmt.Sprintf("math error during %s with operand %f: %s", e.Op, e.Operand, e.Message)
}

func safeSqrt(x float64) (float64, error) {
    if x < 0 {
        return 0, &MathError{
            Op:      "sqrt",
            Operand: x,
            Message: "negative input not allowed",
        }
    }
    return math.Sqrt(x), nil
}

调用后可以通过类型断言获取详细信息：

result, err := safeSqrt(-4)
if err != nil {
    if mathErr, ok := err.(*MathError); ok {
        fmt.Printf("Operation: %s\n", mathErr.Op)
        fmt.Printf("Operand: %f\n", mathErr.Operand)
        fmt.Printf("Message: %s\n", mathErr.Message)
    }
    fmt.Println("Error:", err)
}

使用哨兵错误（Sentinel Errors）

有时你需要预定义一些特定错误值用于比较。这种做法常见于标准库，比如io.EOF：

var ErrInsufficientFunds = errors.New("insufficient funds")

type Account struct {
    Balance float64
}

func (a *Account) Withdraw(amount float64) error {
    if amount > a.Balance {
        return ErrInsufficientFunds
    }
    a.Balance -= amount
    return nil
}

调用方可以用errors.Is进行判断：

err := account.Withdraw(100)
if errors.Is(err, ErrInsufficientFunds) {
    fmt.Println("Not enough money!")
}

包装与链式错误

从Go 1.13开始，支持用%w动词包装错误，形成错误链：

func readFile(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return fmt.Errorf("failed to read file %s: %w", filename, err)
    }
    // 处理数据...
    return nil
}

func processFile(filename string) error {
    err := readFile(filename)
    if err != nil {
        return fmt.Errorf("processing failed: %w", err)
    }
    return nil
}

你可以使用errors.Unwrap、errors.Is或errors.As分析错误链：

err := processFile("nonexistent.txt")
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("File does not exist")
}

var pathError *os.PathError
if errors.As(err, &pathError) {
    fmt.Printf("Path error occurred on path: %s\n", pathError.Path)
}

总结： Go的错误处理强调显式性和可组合性。你可以根据需求选择简单字符串错误、自定义结构体错误，或利用哨兵错误和错误包装构建清晰的错误传播链。关键是让调用者能方便地识别和处理不同类型的错误情况。

基本上就这些，掌握这些模式后，你的Go项目错误处理会更规范、更易维护。