为什么 *A 在 switch case 中无法匹配

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《为什么 *A 在 switch case 中无法匹配》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

刚刚开始学习泛型。我正在制作一个命令处理器，老实说我不知道​​如何表达，所以我只展示一个示例问题：

var errinvalidcommand = errors.new("invalid command")

type transactionalfn[t any] func(ctx context.context, db t) error

func newtransactionalcommand[t any](fn transactionalfn[t]) *transactionalcommand[t] {
    return &transactionalcommand[t]{
        fn: fn,
    }
}

type transactionalcommand[t any] struct {
    fn transactionalfn[t]
}

func (cmd *transactionalcommand[t]) starttransaction() error {
    return nil
}

func (cmd *transactionalcommand[t]) commit() error {
    return nil
}

func (cmd *transactionalcommand[t]) rollback() error {
    return nil
}

type cmd interface{}

type commandmanager struct{}

func (m *commandmanager) handle(ctx context.context, cmd cmd) error {
    switch t := cmd.(type) {
    case *transactionalcommand[any]:
        return m.handletransactionalcommand(ctx, t)
    default:
        fmt.printf("%t\n", cmd)
        return errinvalidcommand
    }
}

func (m *commandmanager) handletransactionalcommand(ctx context.context, cmd *transactionalcommand[any]) error {
    if err := cmd.starttransaction(); err != nil {
        return err
    }

    if err := cmd.fn(ctx, nil); err != nil {
        if err := cmd.rollback(); err != nil {
            return err
        }
    }

    if err := cmd.commit(); err != nil {
        return err
    }

    return nil
}

// tests
type db struct{}

func (*db) do() {
    fmt.println("doing stuff")
}

func testcmd(t *testing.t) {
    ctx := context.background()
    fn := func(ctx context.context, db *db) error {
        fmt.println("test cmd")
        db.do()
        return nil
    }
    tfn := bus.newtransactionalcommand(fn)

    mng := &bus.commandmanager{}
    err := mng.handle(ctx, tfn)
    if err != nil {
        t.fatal(err)
    }
}

mng.handle 返回 errinvalidcommand，因此测试失败，因为 cmd 是 *transactionalcommand[*db] 而不是 *transactionalcommand[any]

让我举另一个更抽象的例子：

type A[T any] struct{}

func (*A[T]) DoA() { fmt.Println("do A") }

type B[T any] struct{}

func (*B[T]) DoB() { fmt.Println("do B") }

func Handle(s interface{}) {
    switch x := s.(type) {
    case *A[any]:
        x.DoA()
    case *B[any]:
        x.DoB()
    default:
        fmt.Printf("%T\n", s)
    }
}



func TestFuncSwitch(t *testing.T) {
    i := &A[int]{}

    Handle(i) // expected to print "do A"
}

为什么这个 switch 语句 case *a[any] 与 *a[int] 不匹配？ 如何使 commandmanager.handle(...) 接受通用命令？

正确答案

*a[any] 与 *a[int] 不匹配，因为 any 是静态类型，而不是通配符。因此，实例化具有不同类型的通用结构 yields different types。

为了正确匹配类型开关中的泛型结构，您必须使用类型参数实例化它：

func handle[t any](s interface{}) {
    switch x := s.(type) {
    case *a[t]:
        x.doa()
    case *b[t]:
        x.dob()
    default:
        panic("no match")
    }
}

虽然没有其他函数参数来推断 t，但您必须使用显式实例化来调用 handle。 t 不会单独从结构中推断出来。

func main() {
    i := &a[int]{}
    handle[int](i) // expected to print "do a"
}

演示：https://go.dev/play/p/2e5E9LSWPmk

但是，当 handle 实际上是一个方法时（如在数据库代码中一样），这存在在实例化接收器时选择类型参数的缺点。

为了改进此处的代码，您可以将 handle 设为顶级函数：

func handle[t any](ctx context.context, cmd cmd) error {
    switch t := cmd.(type) {
    case *transactionalcommand[t]:
        return handletransactionalcommand(ctx, t)
    default:
        fmt.printf("%t\n", cmd)
        return errinvalidcommand
    }
}

然后你就会遇到如何向命令函数提供参数 db t 的问题。为此，您可以：

• 只需将额外的 *db 参数传递给 handle 和 handletransactionalcommand，这也有助于类型参数推断。调用为 handle(ctx, &db{}, tfn)。演示：https://go.dev/play/p/6WESb86KN5D

• 传递 commandmanager 的实例（类似于上面的解决方案，但 *db 被包装）。更加冗长，因为它需要到处显式实例化。演示：https://go.dev/play/p/SpXczsUM5aW

• 改用参数化接口（如下所示）。所以你甚至不需要类型转换。演示：https://go.dev/play/p/EgULEIL6AV5

type cmd[t any] interface {
    exec(ctx context.context, db t) error
}

为什么泛型类型开关编译失败？

• 这实际上是 go 团队有意决定的结果。事实证明，允许参数化类型上的类型切换可能会导致混乱

• 来自Type Parameters Proposal

让我把强调的语句变成代码。如果类型约束使用类型近似（注意波浪号）...

func printstringorint[t ~string | ~int](v t)

...如果还有一个以 int 作为基础类型的自定义类型...

type 秒 int

...如果使用 seconds 参数调用 printorstring()...

printstringorint(秒(42))

...那么 switch 块将不会进入 int 情况 ，而是直接进入 默认情况 ，因为 seconds 不是 int。开发人员可能期望 case int: 也与 seconds 类型匹配。

要允许 case 语句匹配 seconds 和 int 将需要新的语法，例如，

case ~int:

在撰写本文时，讨论仍在进行中，也许它将产生一个用于切换类型参数的全新选项（例如，switch 类型 t）。

更多详情请参考proposal: spec: generics: type switch on parametric types

技巧：将类型转换为“any”

幸运的是，我们不需要等待该提案在未来版本中实施。现在有一个超级简单的解决方法。

不要打开 v.(type)，而是打开 any(v).(type)。

switch any(v).(type) {
    ...

此技巧将 v 转换为空的 interface{}（又名 any），switch 会愉快地进行类型匹配。

来源：A tip and a trick when working with generics

本篇关于《为什么 *A 在 switch case 中无法匹配》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！