在 Go 中，能否在不同的结构中声明相同的方法？

在 Go 1.18 中，无法在不同的结构中声明相同的方法，即使使用泛型。要实现跨多个结构的通用方法，需要使用基类型和结构嵌入或实现公共接口。但是，如果基类型不包含所需的方法，则会出现运行时错误。

有没有办法将 golang 1.18 泛型与结构方法一起使用？即像这样，我对于 foo 和 bar 有一个通用方法 sayname：

package main

import (
    "fmt"
)

type foo struct {
    name     string
    number   int
    fooid string
}

type bar struct {
    name     string
    number   int
    barid string
}

func  [t foo|bar](x *t) sayname() {
    fmt.printf("%d \"%s\"", x.number, x.name)
}

func main() {
    foo := foo{name: "name 1", number: 1, fooid: "foo123"}
    foo.sayname()

    bar := bar{name: "name 2", number: 2, barid: "bar456"}
    bar.sayname()
}

我知道这可以通过使用基类型和结构嵌入或每个接口的其他方式来完成，但这只是一个为了简单起见而设计的示例。

更新：为了让这一点更清楚，如果我有一个稍微不那么做作的例子，如下所示。我了解结构嵌入和使用基本接口。但在下面的情况下，如果 sayname 被定义为 func (b *base) sayname() {... 我会收到运行时错误，因为 base 类型没有 getid 接口（它将是 nil）。所以我想传递一个泛型，它将在 foo 和 bar 实例上具有此接口。我错过了什么吗？

例如，如果我为每种类型复制 sayname 函数（如注释掉的部分所示），下面的代码将全部工作

package main

import (
    "fmt"
)

type Base struct {
    Name   string
    Number int
}

type GetIDIface interface {
    GetID() string
}

type Foo struct {
    Base
    GetIDIface
    FooID string
}

func (f *Foo) GetID() string {
    return f.FooID
}

type Bar struct {
    Base
    GetIDIface
    BarID string
}

func (b *Bar) GetID() string {
    return b.BarID
}

func  [T Foo|Bar](x *T) SayName() {
    fmt.Printf("Number %d \"%s\" with ID of %s", x.Number, x.Name, x.GetID())
}

/* THIS WORKS
func (x *Foo) SayName() {
    fmt.Printf("Number %d \"%s\" with ID of %s\n", x.Number, x.Name, x.GetID())
}

func (x *Bar) SayName() {
    fmt.Printf("Number %d \"%s\" with ID of %s\n", x.Number, x.Name, x.GetID())
}*/

func main() {
    foo := Foo{Base: Base{Name: "Name 1", Number: 1}, FooID: "Foo123"}
    foo.SayName()

    bar := Bar{Base: Base{Name: "Name 2", Number: 2}, BarID: "Bar456"}
    bar.SayName()
}

正确答案

无聊但整体更好的解决方案是在每个需要它们的结构上声明这些方法。这也使得结构使用 sayname() 方法实现一个假设的接口（如果您需要的话）。除此之外，没有语言构造可以在不同的接收器上声明相同的方法。

您可以（但不一定应该）做的是使用带有类型约束的通用结构，该类型约束限制为foo和bar，但是you can't access common fields of those structs。所以约束甚至不可能是 foo | bar 正如我们所希望的；相反，您需要访问这些字段的方法。

在您的情况下，您已经拥有 getidiface，foo 和 bar 实现了它，因此您可以嵌入它：

type foobar interface {
    foo | bar
    getidiface
}

type base[t foobar] struct {
    item   t
    name   string
    number int
}

func (x *base[t]) sayname() {
    fmt.printf("number %d \"%s\" with id of %s\n", x.number, x.name, x.item.getid())
}

您可以在 playground 中查看完整的示例。

但是，这颠倒了 base 和 foo/bar 之间的关系。 ie。 base 不再是真正的“基地”；这是一个包装纸。如果您想走这条路，请确保它符合您的应用程序的语义。

另一种方法是使用顶级函数，该函数采用具有必要功能的接口。这样就不需要泛型了：

type Base struct {
    Name   string
    Number int
}

// Add getter on the base type itself
func (b Base) GetBase() Base {
    return b
}

type Foo struct {
    Base // embedding Base promotes GetBase() too
    FooID string
}
// other Foo methods

type Bar struct {
    Base // embedding Base promotes GetBase() too
    BarID string
}
// other Bar methods

// interface with required functionality
type Sayer interface {
    GetBase() Base
    GetIDIface
}

func SayName(x Sayer) {
    fmt.Printf("Number %d \"%s\" with ID of %s\n", x.GetBase().Number, x.GetBase().Name, x.GetID())
}

演示：https://go.dev/play/p/4RBxW9D53Q8

本篇关于《在 Go 中，能否在不同的结构中声明相同的方法？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！