验证递归的错误接口实现中的 Is() 和 As() 是否能完全避免错误

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《验证递归的错误接口实现中的 Is() 和 As() 是否能完全避免错误》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

在我看来，go 中“包装”错误的“方法”是使用 fmt.errof 和 %w 动词

https://go.dev/blog/go1.13-errors

但是，fmt.errorf 不会递归地包装错误。无法使用它来包装三个先前定义的错误（err1、err2 和 err3），然后使用 is() 检查结果并为这三个错误分别获取 true。

最终编辑：

感谢@mkopriva的回答和下面的评论，我现在有了一个简单的方法来实现这个（尽管，我仍然很好奇是否有一些标准类型可以做到这一点）。由于缺乏示例，我创建示例的尝试失败了。我缺少的部分是向我的类型添加 is 和 as 方法。由于自定义类型需要包含一个错误和指向下一个错误的指针，因此自定义 is 和 as 方法允许我们比较自定义类型中包含的错误，而不是自定义类型本身。

这是一个工作示例：https://go.dev/play/p/6byggib728k

上述链接的要点

type errorchain struct {
    err  error
    next *errorchain
}

//these two functions were the missing ingredient
//defined this way allows for full functionality even if
//the wrapped errors are also chains or other custom types

func (c errorchain) is(err error) bool { return errors.is(c.err, err) }

func (c errorchain) as(target any) bool { return errors.as(c.err, target) }

//omitting error and unwrap methods for brevity

func wrap(errs ...error) error {
    out := errorchain{err: errs[0]}

    n := &out
    for _, err := range errs[1:] {
        n.next = &errorchain{err: err}
        n = n.next
    }
    return out
}

var err0 = errors.new("error 0")
var err1 = errors.new("error 1")
var err2 = errors.new("error 2")
var err3 = errors.new("error 3")

func main() {
    //check basic is functionality
    errs := wrap(err1, err2, err3)
    fmt.println(errs)                            //error 1: error 2: error 3
    fmt.println(errors.is(errs, err0))           //false
    fmt.println(errors.is(errs, err2))           //true
}

虽然 go 源代码特别提到了定义 is 方法的能力，但该示例并没有以可以解决我的问题的方式实现它，而且讨论也没有立即表明需要利用递归性质errors.is。

现在回到原来的帖子：

go 中是否有内置的东西可以发挥作用？

我自己尝试过制作一个（多次尝试），但遇到了不良问题。这些问题源于 go 中的错误似乎是通过地址进行比较的事实。即，如果 err1 和 err2 指向同一事物，则它们是相同的。

这给我带来了问题。我可以天真地让 errors.is 和 errors.as 递归地处理自定义错误类型。这很简单。

1. 创建一个实现错误接口的类型（具有 error() string 方法）
2. 该类型必须有一个代表包装错误的成员，该错误是指向其自身类型的指针。
3. 实现返回包装错误的 unwrap() error 方法。
4. 实现某种方法，将一个错误与另一个错误包装在一起

看起来不错。但有麻烦。

由于错误是指针，如果我做出类似 mywrappederror = wrap(err1, err2) 的内容（在这种情况下假设 err1 被 err2 包裹）。 errors.is(mywrappederror, err1) 和 errors.is(mywrappederror, err2) 不仅会返回 true，而且 errors.is(err2, err1) 也会返回 true

如果需要使 myotherwrappederror = wrap(err3, err2) 并稍后调用 errors.is(mywrappederror, err1) ，它现在将返回 false！使 myotherwrappederror 更改 mywrappederror。

我尝试了多种方法，但总是遇到相关问题。

这可能吗？有没有一个 go 库可以做到这一点？

注意：我对可能已经存在的正确方法更感兴趣，而不是我的基本尝试中错误的具体事情

编辑3：正如其中一个答案所建议的，我的第一个代码中的问题显然是我修改了全局错误。我知道，但未能充分沟通。下面，我将包含其他不使用指针且不修改全局变量的损坏代码。

编辑4：稍微修改一下，使其更有效，但仍然有问题

参见 https://go.dev/play/p/bsytcysbujx

type errorgroup struct {
    err        error
    wrappederr error
}

//...implemention unwrap and error excluded for brevity

func wrap(inside error, outside error) error {
    return &errorgroup{outside, inside}
}

var err1 = errorgroup{errors.new("error 1"), nil}
var err2 = errorgroup{errors.new("error 2"), nil}
var err3 = errorgroup{errors.new("error 3"), nil}

func main() {
    errs := wrap(err1, err2)
    errs = wrap(errs, err3)
    fmt.println(errs)//error 3: error 2: error 1
    fmt.println(errors.is(errs, err1)) //true
    fmt.println(errors.is(errs, err2)) //false <--- a bigger problem
    fmt.println(errors.is(errs, err3)) //false <--- a bigger problem
}

编辑2：演示版本缩短

有关示例，请参阅 https://go.dev/play/p/swfpajbmcxa。

编辑 1：我的代码的精简版本，重点关注重要部分：

type errorGroup struct {
    err        error
    wrappedErr *errorGroup
}

//...implemention Unwrap and Error excluded for brevity

func Wrap(errs ...*errorGroup) (r *errorGroup) {
    r = &errorGroup{}
    for _, err := range errs {
        err.wrappedErr = r
        r = err

    }
    return
}

var Err0 = &errorGroup{errors.New("error 0"), nil}
var Err1 = &errorGroup{errors.New("error 1"), nil}
var Err2 = &errorGroup{errors.New("error 2"), nil}
var Err3 = &errorGroup{errors.New("error 3"), nil}

func main() {
    errs := Wrap(Err1, Err2, Err3)//error 3: error 2: error 1
    fmt.Println(errors.Is(errs, Err1)) //true

    //Creating another wrapped error using the Err1, Err2, or Err3 breaks the previous wrap, errs.
    _ = Wrap(Err0, Err2, Err3)
    fmt.Println(errors.Is(errs, Err1)) //false <--- the problem
}

正确答案

你可以使用这样的东西：

type errorchain struct {
    err  error
    next *errorchain
}

func wrap(errs ...error) error {
    out := errorchain{err: errs[0]}

    n := &out
    for _, err := range errs[1:] {
        n.next = &errorchain{err: err}
        n = n.next
    }
    return out
}

func (c errorchain) is(err error) bool {
    return c.err == err
}

func (c errorchain) unwrap() error {
    if c.next != nil {
        return c.next
    }
    return nil
}

https://go.dev/play/p/6oUGefSxhvF

您的代码修改了包全局错误值，因此它本质上是损坏的。这个缺陷与 go 的错误处理机制无关。

根据您链接的文档，有两个错误处理助手：is 和 as。 is 允许您递归地解包错误，查找特定的错误值，该错误值必须是全局包才能发挥作用。另一方面，as 允许您递归地解包错误，查找给定类型的任何已包装错误值。

包装是如何工作的？您将错误 a 包装在新错误值 b 中。wrap() 帮助程序必然返回一个新值，如 fmt.errorf 在链接文档中的示例中所做的那样。 wrap 帮助程序应该永远修改正在包装的错误的值。该值应该被认为是不可变的。事实上，在任何正常的实现中，该值的类型都是 error，这样您就可以包装任何错误，而不仅仅是将自定义错误类型的同心值包装在一起；并且，在这种情况下，您无论如何都无法访问包装错误的字段来修改它们。本质上，wrap 应该大致是：

func Wrap(err error) error {
    return &errGroup{err}
}

就是这样。这不是很有用，因为您的 errgroup 实现并没有真正执行任何操作 - 它不提供有关发生的错误的详细信息，它只是其他错误的容器。为了让它有价值，它应该有一个 string 错误消息，或者类似其他一些错误类型的 isnotfound 的方法，或者比仅仅使用 error 和 fmt.errorf 更有用的东西。

根据示例代码中的用法，您似乎还假设用例是说“我想将 a 包装在 c 中的 b 中”，但我从未这样做过在野外看到的，我想不出任何需要它的场景。包装的目的是说“我收到了错误 a，我将把它包装在错误 b 中以添加上下文，然后返回它”。调用者可能会将该错误包装在错误c中，等等，这就是递归包装有价值的原因。

例如：https://go.dev/play/p/XeoONx19dgX

今天关于《验证递归的错误接口实现中的 Is() 和 As() 是否能完全避免错误》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！