go - 是否可以在 Go 中定义匿名接口(interface)实现？

Question

考虑一些给定的接口(interface)和使用它的虚构库的函数

// Binary and Ternary operation on ints
type NumOp interface {
    Binary(int, int) int
    Ternary(int, int, int) int
}

func RandomNumOp(op NumOp) {
    var (
        a = rand.Intn(100) - 50
        b = rand.Intn(100) - 50
        c = rand.Intn(100) - 50
    )
    fmt.Printf("%d <op> %d = %d\n", a, b, op.Binary(a,b))
    fmt.Printf("%d <op> %d <op> %d = %d\n", a, b, c, op.Ternary(a,b,c))
}

实现该接口(interface)的可能类型可能是

// MyAdd defines additions on 2 or 3 int variables
type MyAdd struct {}
func (MyAdd) Binary(a, b int) int {return a + b }
func (MyAdd) Ternary(a, b, c int) int {return a + b + c }

我正在处理许多定义一些函数的不同接口(interface)，这些函数在某些情况下需要使用主要作为 NOP 类操作的函数来实现，不依赖于任何结构 member 并且仅在项目中的一个位置使用(不需要可重用性)。

在 Go 中是否有更简单(更简洁)的方式来定义(最好)使用匿名函数的接口(interface)的匿名实现，就像(伪代码，我知道它不是那样工作的):

RandomNumOp({
   Binary: func(a,b int) int { return a+b},
   Ternary: func(a,b,c int) int {return a+b+c},
})

Answer 1

如果实现必须有效

如果实现接口(interface)的值必须有效(例如，它的方法必须可以在没有 panic 的情况下调用)，那么你不能这样做。

方法声明必须在顶层(文件级)。要实现一个具有 0 个以上方法的接口(interface)，需要在某处声明方法。

当然，您可以使用一个结构并嵌入一个现有的实现，但同样，它需要已经有一个现有的实现，其方法必须已经在“某处”定义:在文件级别。

如果您需要一个“虚拟”但可行的实现，他们会使用/传递任何实现，例如MyAdd 类型的值。如果你想强调实现并不重要，那么创建一个虚拟实现，其名称表明:

type DummyOp struct{}

func (DummyOp) Binary(_, _ int) int     { return 0 }
func (DummyOp) Ternary(_, _, _ int) int { return 0 }

如果您需要动态地为一些方法提供实现，您可以创建一个委托(delegate)结构类型来保存这些方法的函数，实际的方法检查是否设置了相应的函数，在调用哪种情况，否则什么都不做。

它可能是这样的:

type CustomOp struct {
    binary  func(int, int) int
    ternary func(int, int, int) int
}

func (cop CustomOp) Binary(a, b int) int {
    if cop.binary != nil {
        return cop.binary(a, b)
    }
    return 0
}

func (cop CustomOp) Ternary(a, b, c int) int {
    if cop.ternary != nil {
        return cop.ternary(a, b, c)
    }
    return 0
}

使用它时，您可以自由地只提供函数的一个子集，其余的将是空操作:

RandomNumOp(CustomOp{
    binary: func(a, b int) int { return a + b },
})

如果实现不需要工作

如果你只需要一个实现接口(interface)的值，但你不需要它的方法是“可调用的”(调用时不会 panic )，你可以简单地使用匿名结构文字，嵌入接口(interface)类型:

var op NumOp = struct{ NumOp }{}