Go 语言多错误优雅处理技巧

本文介绍了在 Go 语言中优雅地处理多个错误的方法，通过定义一个辅助函数和利用短路求值特性，可以将冗长的错误检查代码简化为简洁的链式调用，从而提高代码的可读性和可维护性。

在 Go 语言编程中，经常会遇到需要执行多个可能返回错误的操作的情况。例如，需要将多个结构体序列化为 JSON 字符串。传统的错误处理方式通常是逐个检查每个操作的返回值，这会导致大量的重复代码，降低代码的可读性。

以下展示一种优雅的错误处理方法，它可以显著减少冗余代码，提高代码的可读性。

核心思想：利用闭包和短路求值

该方法的核心在于定义一个辅助函数，该函数接受目标变量和源变量作为参数，并将源变量序列化为 JSON 字符串，并将结果存储到目标变量中。同时，该函数还会返回一个布尔值，指示操作是否成功。如果操作失败，则将错误信息存储在一个全局变量中。

var err error

f := func(dest *[]byte, src interface{}) bool {
    var marshaled []byte
    marshaled, err = json.Marshal(src)
    *dest = marshaled
    return err == nil
}

在上述代码中：

• err 是一个全局变量，用于存储错误信息。
• f 是一个闭包，它接受一个指向 []byte 的指针 dest 和一个 interface{} 类型的 src 作为参数。
• json.Marshal(src) 将 src 序列化为 JSON 字符串，并将结果存储在 marshaled 变量中。如果序列化失败，则将错误信息存储在 err 变量中。
• *dest = marshaled 将 marshaled 的值赋给 dest 指向的变量。
• return err == nil 返回一个布尔值，指示操作是否成功。

链式调用和短路求值

接下来，可以使用 && 运算符将多个辅助函数调用链接在一起。由于 && 运算符具有短路求值的特性，因此如果其中一个操作失败，则后续的操作将不会被执行。

aJson := []byte{}
bJson := []byte{}
cJson := []byte{}
dJson := []byte{}
eJson := []byte{}
fJson := []byte{}
gJson := []byte{}

a := struct{ Name string }{Name: "A"}
b := struct{ Name string }{Name: "B"}
c := struct{ Name string }{Name: "C"}
d := struct{ Name string }{Name: "D"}
e := struct{ Name string }{Name: "E"}
f1 := struct{ Name string }{Name: "F"}
g := struct{ Name string }{Name: "G"}

if f(&aJson, a) &&
    f(&bJson, b) &&
    f(&cJson, c) &&
    f(&dJson, d) &&
    f(&eJson, e) &&
    f(&fJson, f1) &&
    f(&gJson, g) {
    // 所有操作都成功
    fmt.Println("All operations succeeded.")
} else {
    // 至少有一个操作失败
    fmt.Println("At least one operation failed:", err)
}

在上述代码中：

• f(&aJson, a) && ... && f(&gJson, g) 将多个辅助函数调用链接在一起。
• 如果其中一个辅助函数返回 false，则整个表达式的值为 false，并且后续的辅助函数将不会被执行。
• 如果所有辅助函数都返回 true，则整个表达式的值为 true。
• 可以通过检查全局变量 err 的值来判断是否发生了错误。

完整示例

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    var err error

    f := func(dest *[]byte, src interface{}) bool {
        var marshaled []byte
        marshaled, err = json.Marshal(src)
        *dest = marshaled
        return err == nil
    }

    aJson := []byte{}
    bJson := []byte{}
    cJson := []byte{}
    dJson := []byte{}
    eJson := []byte{}
    fJson := []byte{}
    gJson := []byte{}

    a := struct{ Name string }{Name: "A"}
    b := struct{ Name string }{Name: "B"}
    c := struct{ Name string }{Name: "C"}
    d := struct{ Name string }{Name: "D"}
    e := struct{ Name string }{Name: "E"}
    f1 := struct{ Name string }{Name: "F"}
    g := struct{ Name string }{Name: "G"}

    if f(&aJson, a) &&
        f(&bJson, b) &&
        f(&cJson, c) &&
        f(&dJson, d) &&
        f(&eJson, e) &&
        f(&fJson, f1) &&
        f(&gJson, g) {
        // 所有操作都成功
        fmt.Println("All operations succeeded.")
        fmt.Println("aJson:", string(aJson))
        fmt.Println("bJson:", string(bJson))
        fmt.Println("cJson:", string(cJson))
        fmt.Println("dJson:", string(dJson))
        fmt.Println("eJson:", string(eJson))
        fmt.Println("fJson:", string(fJson))
        fmt.Println("gJson:", string(gJson))
    } else {
        // 至少有一个操作失败
        fmt.Println("At least one operation failed:", err)
    }
}

注意事项

• 全局变量 err 必须在函数外部定义，以便在所有辅助函数中都可以访问。
• 如果需要处理不同类型的错误，可以使用 errors.As 或 errors.Is 函数来检查错误的类型。
• 这种方法只适用于简单的错误处理场景。对于更复杂的错误处理场景，可能需要使用更高级的技术，例如错误组或上下文。

总结

通过定义一个辅助函数和利用短路求值特性，可以将冗长的错误检查代码简化为简洁的链式调用。这种方法可以提高代码的可读性和可维护性，并减少冗余代码。在处理多个可能返回错误的操作时，可以考虑使用这种方法来简化错误处理逻辑。