Golang中如何优雅地处理循环中产生的多个错误

errors.Join

error

error

MultiError

package main

import (
    "errors"
    "fmt"
    "strings"
    "sync" // 考虑并发场景
)

// MultiError 是一个自定义的错误类型，用于收集多个错误。
// 它可以被设计成线程安全的，以适应并发场景。
type MultiError struct {
    mu     sync.Mutex // 用于保护 errors 切片在并发访问时的安全
    Errors []error
}

// NewMultiError 创建并返回一个空的 MultiError 实例。
func NewMultiError() *MultiError {
    return &MultiError{
        Errors: make([]error, 0),
    }
}

// Error 方法实现了 error 接口，将所有收集到的错误信息拼接起来。
// 它会按顺序打印每个错误，提供清晰的概览。
func (me *MultiError) Error() string {
    me.mu.Lock()
    defer me.mu.Unlock()

    if len(me.Errors) == 0 {
        return "" // 如果没有错误，返回空字符串
    }

    var sb strings.Builder
    sb.WriteString(fmt.Sprintf("%d errors occurred:\n", len(me.Errors)))
    for i, err := range me.Errors {
        sb.WriteString(fmt.Sprintf("  %d. %s\n", i+1, err.Error()))
    }
    return sb.String()
}

// Add 方法用于向 MultiError 中添加新的错误。
// 它会自动过滤掉 nil 错误，并确保线程安全。
func (me *MultiError) Add(err error) {
    if err == nil {
        return // 忽略 nil 错误
    }
    me.mu.Lock()
    defer me.mu.Unlock()
    me.Errors = append(me.Errors, err)
}

// HasErrors 检查收集器中是否包含任何错误。
func (me *MultiError) HasErrors() bool {
    me.mu.Lock()
    defer me.mu.Unlock()
    return len(me.Errors) > 0
}

// Unwrap 方法（Go 1.13+）允许 errors.Is 和 errors.As 遍历内部错误。
// 对于 MultiError 来说，它应该返回内部的错误切片，这样外部工具就可以检查其中的每一个错误。
func (me *MultiError) Unwrap() []error {
    me.mu.Lock()
    defer me.mu.Unlock()
    return me.Errors
}

func main() {
    collector := NewMultiError() // 使用构造函数创建实例

    // 模拟一些操作，其中一些可能失败
    for i := 1; i <= 5; i++ {
        if i%2 == 0 {
            collector.Add(fmt.Errorf("operation %d failed due to even number", i))
        } else {
            fmt.Printf("Operation %d succeeded.\n", i)
        }
    }

    if collector.HasErrors() {
        fmt.Println("Batch processing completed with issues:")
        fmt.Println(collector.Error())

        // 使用 errors.Is 检查是否存在特定类型的错误
        if errors.Is(collector, fmt.Errorf("operation 2 failed due to even number")) {
            fmt.Println("Specific error for operation 2 was found!")
        }
    } else {
        fmt.Println("All operations completed successfully.")
    }

    // 演示并发场景（虽然这个例子不完全是循环中的并发，但展示了 MultiError 的并发安全性）
    var wg sync.WaitGroup
    for i := 6; i <= 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            if id%2 == 0 {
                collector.Add(fmt.Errorf("concurrent operation %d failed", id))
            } else {
                fmt.Printf("Concurrent operation %d succeeded.\n", id)
            }
        }(i)
    }
    wg.Wait()

    if collector.HasErrors() {
        fmt.Println("\nConcurrent batch processing completed with issues:")
        fmt.Println(collector.Error())
    }
}

MultiError

errors.Join

MultiError

errors.Join

func Join(errs ...error) error

error

error

nil

nil

nil

nil

errors.Join

package main

import (
    "errors"
    "fmt"
)

// CustomError 是一个自定义的错误类型，用于演示 errors.As 的用法
type CustomError struct {
    Code    int
    Message string
}

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

func operation(id int) error {
    switch id {
    case 1:
        return nil
    case 2:
        return fmt.Errorf("network error for op %d", id)
    case 3:
        return &CustomError{Code: 1003, Message: fmt.Sprintf("data validation failed for op %d", id)}
    case 4:
        return errors.New("timeout error")
    default:
        return nil
    }
}

func main() {
    var collectedErrors []error

    for i := 1; i <= 5; i++ {
        err := operation(i)
        if err != nil {
            collectedErrors = append(collectedErrors, err)
        }
    }

    if len(collectedErrors) > 0 {
        finalErr := errors.Join(collectedErrors...) // 合并所有错误
        fmt.Println("Processing completed with aggregated errors:")
        fmt.Println(finalErr.Error())

        fmt.Println("\n--- Checking specific errors ---")

        // 使用 errors.Is 检查是否包含特定的错误
        if errors.Is(finalErr, errors.New("timeout error")) {
            fmt.Println("Found a timeout error among the aggregated errors.")
        }

        // 使用 errors.As 提取特定类型的错误
        var customErr *CustomError
        if errors.As(finalErr, &customErr) {
            fmt.Printf("Found a custom error: Code=%d, Message='%s'\n", customErr.Code, customErr.Message)
        } else {
            fmt.Println("No CustomError found directly via errors.As (might be nested deeper or not present).")
        }

        // 进一步，errors.As 会遍历所有Join的错误。
        // 我们可以手动遍历 `errors.Unwrap(finalErr)` 来展示所有被Join的错误
        // 注意：errors.Unwrap 对于 errors.Join 返回的错误会返回一个 []error
        unwrapped := errors.Unwrap(finalErr)
        if unwrapped != nil {
            fmt.Println("\n--- Unwrapped errors for deeper inspection ---")
            // errors.Unwrap 返回的可能是单个错误，也可能是 []error
            // 对于 errors.Join 而言，它会返回一个切片，所以需要类型断言
            if joinedErrs, ok := unwrapped.([]error); ok {
                for i, e := range joinedErrs {
                    fmt.Printf("  Unwrapped Error %d: %s\n", i+1, e.Error())
                    var ce *CustomError
                    if errors.As(e, &ce) {
                        fmt.Printf("    This unwrapped error is a CustomError: Code=%d\n", ce.Code)
                    }
                }
            }
        }

    } else {
        fmt.Println("All operations completed successfully.")
    }
}

errors.Join

network error

CustomError

timeout error

errors.Is

timeout error

errors.As

CustomError

errors.Join

MultiError

errors.Join

MultiError

errors.Join