Go——优雅地处理多个错误？

Question

有没有办法清理这个 (IMO) 看起来很可怕的代码？

    aJson, err1 := json.Marshal(a)
bJson, err2 := json.Marshal(b)
cJson, err3 := json.Marshal(c)
dJson, err4 := json.Marshal(d)
eJson, err5 := json.Marshal(e)
fJson, err6 := json.Marshal(f)
gJson, err4 := json.Marshal(g)
if err1 != nil {
    return err1
} else if err2 != nil {
    return err2
} else if err3 != nil {
    return err3
} else if err4 != nil {
    return err4
} else if err5 != nil {
    return err5
} else if err5 != nil {
    return err5
} else if err6 != nil {
    return err6
} 

具体来说，我说的是错误处理。能够一次处理所有的错误就好了。

Answer 1

var err error
f := func(dest *D, src S) bool {
    *dest, err = json.Marshal(src)
    return err == nil
} // EDIT: removed ()

f(&aJson, a) &&
    f(&bJson, b) &&
    f(&cJson, c) &&
    f(&dJson, d) &&
    f(&eJson, e) &&
    f(&fJson, f) &&
    f(&gJson, g)
return err

Answer 2

将结果放入切片而不是变量，将初始值放入另一个切片中进行迭代，如果出现错误则在迭代期间返回。

var result [][]byte
for _, item := range []interface{}{a, b, c, d, e, f, g} {
    res, err := json.Marshal(item)
    if err != nil {
        return err
    }
    result = append(result, res)
}

---

您甚至可以重用一个数组而不是两个切片。

var values, err = [...]interface{}{a, b, c, d, e, f, g}, error(nil)
for i, item := range values {
    if values[i], err = json.Marshal(item); err != nil {
        return err
    }
}

当然，这需要类型断言才能使用结果。

Answer 3

定义一个函数。

func marshalMany(vals ...interface{}) ([][]byte, error) {
    out := make([][]byte, 0, len(vals))
    for i := range vals {
        b, err := json.Marshal(vals[i])
        if err != nil {
            return nil, err
        }
        out = append(out, b)
    }
    return out, nil
}

您没有说明您希望错误处理如何工作。失败一个，失败所有？第一个失败？收集成功还是扔掉它们？

Answer 4

我相信这里的其他答案对于您的特定问题是正确的，但更一般地说，panic 可用于缩短错误处理，同时仍然是一个表现良好的库。 （即，不是panicing 跨越包边界。）

考虑：

func mustMarshal(v interface{}) []byte {
    bs, err := json.Marshal(v)
    if err != nil {
        panic(err)
    }
    return bs
}

func encodeAll() (err error) {
    defer func() {
        if r := recover(); r != nil {
            var ok bool
            if err, ok = r.(error); ok {
                return
            }
            panic(r)
        }
    }()

    ea := mustMarshal(a)    
    eb := mustMarshal(b)
    ec := mustMarshal(c)

    return nil
}

当封送值出现问题时，此代码使用mustMarshal 到panic。但是encodeAll 函数将从恐慌中recover 并将其作为正常错误值返回。在这种情况下，客户端永远不会受到恐慌。

但这带有一个警告：在任何地方都使用这种方法是不习惯的。它也可能更糟，因为它不能很好地专门处理每个单独的错误，但或多或​​少地对待每个错误都是一样的。但是当有大量错误需要处理时，它就有它的用处。例如，我在 Web 应用程序中使用这种方法，其中顶级处理程序可以捕获不同类型的错误，并根据错误类型将它们适当地显示给用户（或日志文件）。

当有很多错误处理时，它会产生更简洁的代码，但会失去惯用的 Go 并专门处理每个错误。另一个缺点是它可以防止某些应该恐慌的东西真正恐慌。 （但这可以通过使用您自己的错误类型轻松解决。）

Answer 5

您可以创建一个可重用的方法，然后仅在一个 if 条件下捕获错误。不过，这个实现只会显示最后一个错误。

func hasError(errs ...error) error {
    for i, _ := range errs {
        if errs[i] != nil {
            return errs[i]
        }
    }
    return nil
}

aJson, err := json.Marshal(a)
bJson, err2 := json.Marshal(b)
cJson, err3 := json.Marshal(c)
dJson, err4 := json.Marshal(d)
eJson, err5 := json.Marshal(e)
fJson, err6 := json.Marshal(f)
gJson, err7 := json.Marshal(g)

if error := util.hasError(err, err1, err2, err3, err4, err5, err6, err7); error != nil {
    return error
}

Answer 6

您可以使用 Hashicorp 的go-multierror。

var result error

if err := step1(); err != nil {
    result = multierror.Append(result, err)
}
if err := step2(); err != nil {
    result = multierror.Append(result, err)
}

return result