对自定义错误类型分类是否有一种标准方法

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《对自定义错误类型分类是否有一种标准方法》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

问题内容

是否有一种可接受的模式将自定义错误类型分组在一起，以便我可以根据它们的组以不同的方式处理它们？

例如，以下是我在 c# 中执行的操作（但有例外情况）：

abstract class friendlyexception : applicationexception {
    protected friendlyexception(string message) : base(message) { }
}
class myniceexception : friendlyexception {
    public myniceexception(string message) : base(message) { }
}

然后我可以在 catch 中做一些不同的事情，具体取决于它是否属于该类别：

try { dosomething(); }
catch (friendlyexception ex) { console.writeline(ex.message); }
catch { console.writeline("unhandled error"); }

在 go 中，我发现我可以使用 as 或直接在类型上切换，但由于存在隐式接口，我看不到可以在没有浪费接口成员的情况下完成此操作，如下所示：

type friendlyerror interface { somewastedmethod() }
type myfriendlyerror struct {}
func (fe myfriendlyerror) somewastedmethod() {}
func (fe myfriendlyerror) error() string { return "implementing error interface" }

然后我可以检查该组是否有错误，如下所示：

var fe FriendlyError
err := DoSomething()
if err != nil {
    if errors.As(err, &fe) {
        fmt.Println(err.Error())
    } else {
        fmt.Println("Unhandled error")
    }
}

myfriendlyerror 结构中浪费的方法让我烦恼。这是实现这一目标的唯一方法，还是还有其他标准模式？

在我的示例中，我想要多种不同的错误类型，其中一些可以安全地将消息返回给调用者，而其中一些我只想向调用者提供通用消息，同时仍然保留内部详细信息日志记录。

正确答案

我建议采用以下方式：

package main

import (
    "errors"
    "fmt"
)

var (
    ErrInvalidMsg   = errors.New("invalid message")
    ErrInvalidParam = errors.New("invalid param")
    ErrBadMsg       = errors.New("bad message")
)

type GroupError1 struct {
    Base error
}

func (ge GroupError1) Error() string {
    return ge.Base.Error()
}

type GroupError2 struct {
    Base error
}

func (ge GroupError2) Error() string {
    return ge.Base.Error()
}

func TheError(n int) error {
    switch n % 3 {
    case 0:
        return GroupError2{
            Base: ErrBadMsg,
        }
    case 1:
        return GroupError1{
            Base: ErrInvalidParam,
        }
    case 2:
        return GroupError1{
            Base: ErrInvalidMsg,
        }
    }

    return nil
}

func main() {
    if err := TheError(1); err != nil {
        var ge1 GroupError1
        var ge2 GroupError2

        if ok := errors.As(err, &ge1); ok {
            fmt.Println("error group 1")
        } else if ok := errors.As(err, &ge2); ok {
            fmt.Println("error group 2")
        } else {
            fmt.Println("no error group")
        }
    }
}

这里我定义了两个错误组，所以我们可以用errors.as来检测它们，并且你不需要定义任何未使用的接口，但你需要手动创建它们，并且没有任何自动分组。

理论要掌握，实操不能落！以上关于《对自定义错误类型分类是否有一种标准方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注编程网公众号吧！