Go中如何替代重复的错误处理代码？

首先明确：Go没有其他语言中类似try-catch的异常捕获机制，它的错误处理是显式设计的核心特性——强制开发者直面错误，避免隐藏的异常逻辑。但对于你这种重复的if err != nil代码，确实有几种实用的优化方式：

1. 用闭包封装批量操作的错误处理 #

把需要执行的一系列带错误返回的操作，封装到一个匿名闭包里，只在闭包执行完成后做一次错误检查：

func yourFunc() (*SomeResult, error) {
    var a AType
    var b BType
    var c CType

    // 把所有需要检查错误的操作放进闭包
    err := func() error {
        var innerErr error
        a, innerErr = A()
        if innerErr != nil {
            return innerErr
        }
        b, innerErr = B()
        if innerErr != nil {
            return innerErr
        }
        c, innerErr = C()
        if innerErr != nil {
            return innerErr
        }
        return nil
    }()

    // 只需要在这里统一处理错误
    if err != nil {
        return nil, err
    }

    // 后续正常使用a、b、c
    return process(a, b, c), nil
}

这种方式既保留了显式错误处理的特性，又避免了重复的返回语句。

2. 封装通用的错误检查辅助函数 #

如果你的场景里有大量类似的“调用函数→检查错误”逻辑，可以写一个通用辅助函数来简化：

// checkResult 针对带返回值的函数，封装错误检查逻辑（Go 1.18+支持泛型）
func checkResult[T any](fn func() (T, error)) (T, error) {
    return fn()
}

使用时可以简化成：

a, err := checkResult(A)
if err != nil {
    return nil, err
}
b, err := checkResult(B)
if err != nil {
    return nil, err
}

虽然还是要写if err != nil，但减少了重复的函数调用写法，适合需要保留每一步错误上下文的场景。

3. 链式调用（适合步骤间有依赖的场景） #

如果后续操作依赖前一步的结果，可以把错误检查逻辑融入链式调用中，通过函数封装让每一步职责更清晰：

func stepA() (AType, error) { return A() }
func stepB(a AType) (BType, error) { return B() } // 假设B依赖a的结果
func stepC(b BType) (CType, error) { return C() } // 假设C依赖b的结果

func yourFunc() (*SomeResult, error) {
    a, err := stepA()
    if err != nil {
        return nil, err
    }
    b, err := stepB(a)
    if err != nil {
        return nil, err
    }
    c, err := stepC(b)
    if err != nil {
        return nil, err
    }
    return process(a, b, c), nil
}

注意 #

Go官方不推荐用“隐藏错误”的方式简化代码——比如忽略错误或用第三方库模拟try-catch，这会违背Go显式错误处理的设计初衷，反而让代码更难维护。

内容的提问来源于stack exchange，提问作者joe1531