Go - 我如何子类型一个包装的错误类？

Question

我正在包装错误（以添加上下文），然后区分两个错误。这是我目前用于测试的场景。 （函数是否正确识别错误？）我的问题是如何减少冗长。

我有两个函数会产生不同的错误：

func a() error {
    return errors.New("a")
}

func b() error {
    return errors.New("b")
}

它们都由传播错误的第三个函数调用。

func doStuff() error {
    err := a()
    if err != nil {
        return WrapA{err}
    }
    err = b()
    if err != nil {
        return WrapB{err}
    }
    return nil
}

在我的主要功能中，我区分了这两个错误。

func main() {
    fmt.Println("Hello, playground")
    err := doStuff()
    
    switch err.(type) {
        case WrapA:
            fmt.Println("error from doing a")
        case WrapB: 
            fmt.Println("error from doing b")
        case nil:
            fmt.Println("nil")
        default:
            fmt.Println("unknown")
    }
}

到目前为止，一切都很好。不幸的是，要实现WrapA 和WrapB，我需要很多代码：

type WrapA struct {
    wrappedError error
}

func (e WrapA) Error() string {
    return e.wrappedError.Error()
}

func (e WrapA) Unwrap() error {
    return e.wrappedError
}

type WrapB struct {
    wrappedError error
}

func (e WrapB) Error() string {
    return e.wrappedError.Error()
}

func (e WrapB) Unwrap() error {
    return e.wrappedError
}

在其他语言中，我将创建一个 Wrap 结构并让 WrapA 和 WrapB 从 Wrap 继承。但我没有看到在 Go 中执行此操作的方法。

关于如何减少混乱的任何想法？

去游乐场https://play.golang.org/p/ApzHC_miNyV

编辑： 看到 jub0bs 的回答后，我想澄清一下： a() 和 b() 都是我无法控制的回调。他们可能会返回各种错误。这就是我包装它们的原因。

Answer 1

如果可以，请使用constant errors。然后你可以打开错误本身。

Answer 2

如果我对问题的理解正确，您确实可以简化事情：

• 将 a 和 b 定义为包级别的 error 变量，以便轻松获得更好的性能。
• 除非您需要以编程方式访问只能在您包装的错误上下文中访问的值，否则您很可能不需要声明这些自定义 WrapA 和 WrapB 错误类型。相反，您可以简单地使用 the %w verb in conjunction with fmt.Errorf 来生成一个新的错误值来包装较低级别的错误。
• 然后您可以在无标记的switch 中使用errors.Is 来检查doStuff 函数返回的更高级别错误的原因。

(Playground)

package main

import (
    "errors"
    "fmt"
)

var (
    a = errors.New("a")
    b = errors.New("b")
)

func doStuff() error {
    err := a
    if err != nil {
        return fmt.Errorf("%w", err)
    }
    err = b
    if err != nil {
        return fmt.Errorf("%w", err)
    }
    return nil
}

func main() {
    fmt.Println("Hello, playground")
    switch err := doStuff(); {
    case errors.Is(err, a):
        fmt.Println("error from doing a")
    case errors.Is(err, b):
        fmt.Println("error from doing b")
    case err == nil:
        fmt.Println("nil")
    default:
        fmt.Println("unknown")
    }
}

Answer 3

添加一个结构化的错误版本，该版本构成一个类型 Wrap 以及各种更具体的错误类型；

package main

import (
    "errors"
    "fmt"
)

func a() error {
    return errors.New("something more specific broke in a")
}

func b() error {
    return errors.New("something more specific broke in b")
}

func doStuff() error {
    err := a()
    if err != nil {
        return ErrA{
            Wrap:        Wrap{err: err},
            SpecficProp: "whatever",
        }
    }
    err = b()
    if err != nil {
        return ErrB{
            Wrap:         Wrap{err: err},
            SpecficProp2: "whatever else",
        }
    }
    return nil
}

func main() {
    fmt.Println("Hello, playground")
    err := doStuff()

    if target := (ErrA{}); errors.As(err, &target) {
        fmt.Printf("%v\n", target)
    } else if target := (ErrB{}); errors.As(err, &target) {
        fmt.Printf("%v\n", target)
    } else if err != nil {
        fmt.Println("unknown")
    } else {
        fmt.Println("nil")
    }
}

type Wrap struct {
    err error
}

func (e Wrap) Error() string {
    return e.err.Error()
}

func (e Wrap) Unwrap() error {
    return e.err
}

type ErrA struct {
    Wrap
    SpecficProp interface{}
}

func (e ErrA) Error() string {
    return fmt.Sprintf("got error of kind A with %#v, plus %T", e.SpecficProp, e.Unwrap())
}

type ErrB struct {
    Wrap
    SpecficProp2 interface{}
}

func (e ErrB) Error() string {
    return fmt.Sprintf("got error of kind B with %#v, plus %T", e.SpecficProp2, e.Unwrap())
}