避免检查错误是否是零重复？

Question

我目前正在学习围棋，我的一些代码如下所示：

a, err := doA()
if err != nil {
  return nil, err
}
b, err := doB(a)
if err != nil {
  return nil, err
}
c, err := doC(b)
if err != nil {
  return nil, err
}
... and so on ...

这对我来说看起来有点不对，因为错误检查占用了大部分行。有没有更好的方法来进行错误处理？我可以通过一些重构来避免这种情况吗？

更新：感谢您的所有回答。请注意，在我的示例中，doB 取决于 a，doC 取决于 b，依此类推。因此，大多数建议的重构在这种情况下都不起作用。还有什么建议吗？

Answer 1

这是一个常见的抱怨，有几个答案。

以下是一些常见的：

1 - 还不错

这是对这些投诉的一种非常常见的反应。您的代码中有几行额外的代码实际上并没有那么糟糕。这只是一种廉价的打字方式，并且在阅读方面非常容易处理。

2 - 这其实是件好事

这是基于这样一个事实，即键入和阅读这些额外的行是一个很好的提醒，实际上您的逻辑可能会在此时逃脱，并且您必须撤消在这些行中设置的任何资源管理在它之前。与异常相比，这通常会被提出，异常会以隐含的方式破坏逻辑流程，从而迫使开发人员始终牢记隐藏的错误路径。前段时间我写了一篇关于这个here的更深入的咆哮。

3 - 使用恐慌/恢复

在某些特定情况下，您可以通过将panic 与已知类型一起使用，然后在您的包代码发布之前使用recover，将其转换为适当的错误并返回来避免其中的一些工作相反。这种技术最常用于展开递归逻辑，例如 (un)marshalers。

我个人尽量不过度滥用这一点，因为我与第 1 点和第 2 点的关联更密切。

4 - 稍微重新组织一下代码

在某些情况下，您可以稍微重新组织逻辑以避免重复。

举个简单的例子，这个：

err := doA()
if err != nil {
    return err
}
err := doB()
if err != nil {
    return err
}
return nil

也可以组织为：

err := doA()
if err != nil {
    return err
}
return doB()

5 - 使用命名结果

有些人使用命名结果从 return 语句中去除 err 变量。不过，我建议不要这样做，因为它节省的资源很少，降低了代码的清晰度，并且当在 bail-out return 语句之前定义了一个或多个结果时，逻辑容易出现微妙的问题。

6 - 使用 if 条件之前的语句

正如 Tom Wilde 在下面的评论中很好地提醒的那样，Go 中的 if 语句位于条件之前的 accept a simple statement。所以你可以这样做：

if err := doA(); err != nil {
    return err
}

这是一个很好的围棋成语，并且经常使用。

在某些特定情况下，我宁愿避免以这种方式嵌入声明，只是为了使其独立，以便清楚起见，但这是一件微妙且个人的事情。

Answer 2

你可以使用命名的返回参数来缩短一些东西

Playground link

func doStuff() (result string, err error) {
    a, err := doA()
    if err != nil {
        return
    }
    b, err := doB(a)
    if err != nil {
        return
    }
    result, err = doC(b)
    if err != nil {
        return
    }
    return
}

在您使用 Go 编程一段时间后，您会意识到必须检查每个函数的错误会让您思考如果该函数出错的实际含义以及您应该如何处理它。

Answer 3

如果您有许多此类重复发生的情况，其中您有几种情况 错误检查，您可以为自己定义一个实用函数，如下所示：

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

这使您可以选择错误之一，如果有错误则返回 是非零。

使用示例（full version on play）：

x, err1 := doSomething(2)
y, err2 := doSomething(3)

if e := validError(err1, err2); e != nil {
    return e
}

当然，这只能在函数不相互依赖的情况下应用 但这是总结错误处理的一般前提条件。

Answer 4

您可以创建带有结果值和错误的上下文类型。

type Type1 struct {
    a int
    b int
    c int

    err error
}

func (t *Type1) doA() {
    if t.err != nil {
        return
    }

    // do something
    if err := do(); err != nil {
        t.err = err
    }
}

func (t *Type1) doB() {
    if t.err != nil {
        return
    }

    // do something
    b, err := t.doWithA(a)
    if err != nil {
        t.err = err
        return
    }

    t.b = b
}

func (t *Type1) doC() {
    if t.err != nil {
        return
    }

    // do something
    c, err := do()
    if err != nil {
        t.err = err
        return
    }

    t.c = c
}

func main() {

    t := Type1{}
    t.doA()
    t.doB()
    t.doC()

    if t.err != nil {
        // handle error in t
    }

}

Answer 5

这对您来说可能是错误的，因为您习惯于不在呼叫站点处理错误。这对于 go 来说是非常惯用的，但如果你不习惯它，它看起来就像很多样板。

它确实有一些优点。

1. 您必须考虑在产生错误的站点上处理此错误的正确方法是什么。
2. 很容易阅读代码以查看代码中止和提前返回的每个点。

如果它确实让您感到困扰，您可以使用 for 循环和匿名函数来发挥创意，但这通常会变得复杂且难以阅读。

Answer 6

您可以将错误作为函数参数传递

func doA() (A, error) {
...
}
func doB(a A, err error)  (B, error) {
...
} 

c, err := doB(doA())

我注意到“html/template”包中的一些方法可以做到这一点，例如

func Must(t *Template, err error) *Template {
    if err != nil {
        panic(err)
    }
    return t
}