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可以用来缩短错误处理,同时仍然是一个表现良好的库.(即,不panic跨越包边界.)

考虑:

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并专门处理每个错误.另一个不利的方面是,它可以防止东西,应该从实际panicing恐慌.(但这可以通过使用您自己的错误类型轻松解决.)