Golang中如何实现可持有两个无共同点接口的类型

Golang中如何实现可持有两个无共同点接口的类型 你好，

在我正在编写的程序中，我有两个接口类型（以及其他类型），它们没有共同的方法。

我们称它们为 A 和 B。

type A interface { /* A 的方法集 */ }
type A interface { /* B 的方法集 */ }

现在我需要一个可以容纳其中任意一个的类型。

我首先想到的是空接口，然后使用类型断言来确定我拥有的是 A 还是 B。

有没有办法避免在这里使用空接口？我有点不愿意使用它，因为那样会失去静态检查。

2 回复

你可以定义一个包含一个永远不会使用的非导出函数的接口：

type AorB interface {
    aorb()
}

type A struct { /* ... */ }

func (A) aorb() {}

type B struct { /* ... */ }

func (B) aorb() {}

https://play.golang.org/p/qqvsSJFdagP

更多关于Golang中如何实现可持有两个无共同点接口的类型的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go中，处理这种情况的常见方法是使用带有类型参数的泛型。从Go 1.18开始，你可以定义一个泛型类型，它可以持有A或B，同时保持类型安全。

示例：

package main

import "fmt"

type A interface {
    MethodA()
}

type B interface {
    MethodB()
}

// 泛型容器类型
type Container[T any] struct {
    value T
}

func NewContainer[T any](v T) Container[T] {
    return Container[T]{value: v}
}

func (c Container[T]) Get() T {
    return c.value
}

// 使用示例
type ImplA struct{}

func (i ImplA) MethodA() {
    fmt.Println("MethodA called")
}

type ImplB struct{}

func (i ImplB) MethodB() {
    fmt.Println("MethodB called")
}

func main() {
    // 创建持有A的容器
    containerA := NewContainer[A](ImplA{})
    a := containerA.Get()
    a.MethodA() // 输出: MethodA called
    
    // 创建持有B的容器
    containerB := NewContainer[B](ImplB{})
    b := containerB.Get()
    b.MethodB() // 输出: MethodB called
}

如果你需要同一个变量能够动态地持有A或B，可以使用类型断言，但通过自定义接口来提供更好的类型安全：

type Holder interface {
    Value() any
    IsA() bool
    IsB() bool
}

type holder struct {
    value any
}

func NewHolderForA(a A) Holder {
    return &holder{value: a}
}

func NewHolderForB(b B) Holder {
    return &holder{value: b}
}

func (h *holder) Value() any {
    return h.value
}

func (h *holder) IsA() bool {
    _, ok := h.value.(A)
    return ok
}

func (h *holder) IsB() bool {
    _, ok := h.value.(B)
    return ok
}

// 使用示例
func processHolder(h Holder) {
    if h.IsA() {
        a := h.Value().(A)
        a.MethodA()
    } else if h.IsB() {
        b := h.Value().(B)
        b.MethodB()
    }
}

另一种方法是使用带有类型参数的函数：

func Process[T A | B](value T) {
    switch v := any(value).(type) {
    case A:
        v.MethodA()
    case B:
        v.MethodB()
    }
}

这些方法都比直接使用空接口提供了更好的类型安全性，同时避免了在代码中到处使用类型断言。

回到顶部