Golang 最佳实践：在返回值中使用空数组还是错误？

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《Golang 最佳实践：在返回值中使用空数组还是错误？》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

对于接受对象切片并返回另一对象切片（理想情况下与输入数组长度相同）以及错误的函数，在错误处理方面有哪些最佳实践，如下所示：

func ([]interface{}) ([]interface{}, error)

一种方法是，每当您在处理切片中的一个对象时遇到错误时，您都会返回一个错误响应，但是这样在接收函数中，如果您不丢弃所有切片元素，错误响应就会变得很小使用仅告诉我们其中一个元素或所有元素的处理失败。另一种方法是当没有任何元素得到处理时返回错误，但我觉得这没什么用处。另一种方法是您不包含错误作为返回对象，而是对于每个切片元素结构，将其自己的错误对象作为复合体，以便您可以发送元素错误作为输出。

最好的方法显然取决于特定的场景，但是，我想知道人们是否遵循任何最佳实践或围绕此问题的任何设计模式。

ps：这是最接近的问题之一，但是由于它接受单个对象作为输入，所以不是很相关： 返回空数组或错误

解决方案

您还没有告诉我们足够的信息，无法继续。

• 返回的切片实际上与参数切片有什么关系吗？
• 如果有，他们之间是什么关系？例如，返回的切片可能应该是输入切片大小的一半，并且当且仅当输入对象的数量为奇数时才会发生错误，在这种情况下，最后一个输入对象将被忽略。
• 输入必须按顺序处理，还是并行处理？

如果输出与输入是一对一的，并且您打算并行处理它们和/或在遇到一个坏输入时继续处理剩余的输入，那么这可能是一种明智的方法。同样，您可以让输出切片包含错误。

这确实非常依赖于问题。

编辑：考虑例如以下内容（请注意，我并不认为这是好的）：

const maxworkers = 10 // tunable

// process a slice of t's in parallel.  the results are either an
// r for each t, or an error.  caller provides the actual function
// f(t), which returns r + error (an empty/zero r for error).
func processinparallel(input []t, f func(t) (r, error)) ([]interface{}, error) {
    // make one channel for sending work to workers,
    // and one for receiving results from workers.
    type todo struct {
        i    int // the index of the item
        item t   // the item to work on
    }
    workchan := make(chan todo)
    type done struct {
        i int   // the index of the item worked on
        r r     // result, if we have one
        e error // error, if we have one
    }
    donechan := make(chan done)

    // spin off workers: maxworkers or len(input),
    // whichever is smaller.
    n := len(input)
    if n > maxworkers {
        n = maxworkers
    }
    var wg sync.waitgroup
    for i := 0; i < n; i++ {
        wg.add(1)
        go func(i int) {
            for todo := range workchan {
                i := todo.i
                r, err := f(input[i])
                donechan <- done{i, r, err}
            }
            wg.done()
        }(i)
    }

    // close donechan when all workers finish.
    go func() {
        wg.wait()
        close(donechan)
    }()

    // hand out work to workers (then close work channel).
    go func() {
        for i := range input {
            workchan <- todo{i, input[i]}
        }
        close(workchan)
    }()

    // collect results.
    var anyerr error
    ret := make([]interface{}, len(input))
    for done := range donechan {
        i := done.i
        r, err := done.r, done.e
        if err != nil {
            anyerr = err
            ret[i] = err
        } else {
            ret[i] = r
        }
    }
    return ret, anyerr
}

这有一个整体错误返回，并且它返回 interface{} 的切片。这意味着您可以立即判断一切是否正常。然而，使用起来有点烦人：

ret, err := processinparallel(arg, f)
if err != nil {
    fmt.println("some inputs failed")
    for i := range ret {
        if e, ok := ret[i].(error); ok {
            fmt.printf("%d: failed: %v\n", i, e)
        } else {
            fmt.printf("%d: %s\n", i, ret[i].(r))
        }
    }
} else {
    fmt.println("all inputs were good")
    for i := range ret {
        fmt.printf("%d: %s\n", i, ret[i].(r))
    }
}

为什么要费心所有错误摘要？

相反，我们可以让 processinparallel 返回 []r、[]error，或者（可能更好）使用简单的 error 接口返回值将 MultiError 存储为 Cerise Limón suggested in a comment：

ret, err := ProcessInParallel(arg, f)
if err != nil {
    if merr, ok := err.(datastore.MultiError); ok {
        // merr[i] indicates the various failed items
        // any ret[i] for which merr[i] is nil is OK
    }
} else {
    // all ret[i] are ok
}

不使用 multierror 的工作示例是 here。

使用 multierror 的工作示例是 here。

今天关于《Golang 最佳实践：在返回值中使用空数组还是错误？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！