Go函数中处理多个错误的方法

在Go语言的编程实践中，函数常常需要处理多个错误情况。合理有效地处理这些错误，对于保障程序的稳定性和可靠性至关重要。

我们可以使用 error 接口数组来收集多个错误。例如，当一个函数需要执行多个独立的操作，每个操作都可能返回错误时，就可以定义一个 error 类型的切片。

func processTasks() []error {
    var errors []error
    err1 := task1()
    if err1!= nil {
        errors = append(errors, err1)
    }
    err2 := task2()
    if err2!= nil {
        errors = append(errors, err2)
    }
    return errors
}

在调用 processTasks 函数后，调用者可以遍历这个错误数组，根据不同的错误进行相应的处理。这种方式简单直接，适用于需要记录所有错误的场景。

fmt.Errorf 结合字符串格式化是另一种常用的方法。当多个错误需要合并成一个有意义的错误信息时，就可以使用这种方式。

func combinedError() error {
    err1 := task1()
    err2 := task2()
    if err1!= nil && err2!= nil {
        return fmt.Errorf("task1 failed: %v, task2 failed: %v", err1, err2)
    } else if err1!= nil {
        return fmt.Errorf("task1 failed: %v", err1)
    } else if err2!= nil {
        return fmt.Errorf("task2 failed: %v", err2)
    }
    return nil
}

这种方法将多个错误信息整合在一起，方便调用者了解错误的全貌。

另外，context 包在处理多个错误时也能发挥重要作用。在并发场景下，我们可以利用 context 来取消操作并传播错误。

func concurrentTasks(ctx context.Context) error {
    var wg sync.WaitGroup
    var mu sync.Mutex
    var finalErr error

    task1 := func() {
        defer wg.Done()
        err := task1()
        if err!= nil {
            mu.Lock()
            if finalErr == nil {
                finalErr = err
            }
            mu.Unlock()
        }
    }

    task2 := func() {
        defer wg.Done()
        err := task2()
        if err!= nil {
            mu.Lock()
            if finalErr == nil {
                finalErr = err
            }
            mu.Unlock()
        }
    }

    wg.Add(2)
    go task1()
    go task2()
    wg.Wait()
    return finalErr
}

通过 context，我们可以在并发任务中优雅地处理错误，确保在适当的时候终止操作并返回正确的错误信息。

Go语言提供了多种处理多个错误的方法，开发者需要根据具体的业务场景选择最合适的方式，以提高程序的质量和稳定性。