有一个接口声明和许多实现它的结构

type datainterface interface {
    get(string) string
}

type dataa struct {
    d map[string]string
}

func (d *dataa) get(key string) string {
    return d.d[key]
}

func (d *dataa) getid() string {
    return d.get("id")
}

type datab struct {
    d map[string]string
}

func (d *datab) get(key string) string {
    return d.d[key]
}

func (d *datab) getfile() string {
    return d.get("file")
}


type datac...

还包括 datac,d,e...

我会将这些 datax 结构实例存储到 type dataslice []datainterface

现在，如果我想获取 datax ，我可以这样做：

type dataslice []datainterface
func (d dataslice) geta() []*dataa {
    var ret []*dataa
    for _, di := range d {
        if v, ok := di.(*dataa); ok {
            ret = append(ret, v)
        }
    }
    return ret
}

func (d dataslice) getb() []*datab {
    var ret []*datab
    for _, di := range d {
        if v, ok := di.(*datab); ok {
            ret = append(ret, v)
        }
    }
    return ret
}

func (d dataslice) getc() .....

显然这里有很多重复的代码：

var ret []*datax
for _, di := range d {
    if v, ok := di.(*datax); ok {
        ret = append(ret, v)
    }
}

所以我想我可以使用泛型来解决这个问题，然后我定义了这个函数：

func GetDataX[T any] (d DataInterface) *T {
    return d.(*T)
}

但出现错误：impossible 类型断言：'*t' 未实现 'datainterface

所以我想知道这样真的不可能吗？或者可以通过其他方式完成？

正确答案

您应该能够使用以下代码来满足您的需求：

package main

import "fmt"

// interface
type DataInterface interface {
    Get(string) string
}

// struct implementing the interface
type DataA struct {
    d map[string]string
}

func (d DataA) Get(key string) string {
    return d.d[key]
}

type DataB struct {
    d map[string]string
}

func (d DataB) Get(key string) string {
    return d.d[key]
}

type DataSlice []DataInterface

func GetDataX[T any](d DataInterface) T {
    return d.(T)
}

func main() {
    a := DataA{map[string]string{"a": "1"}}
    b := DataB{map[string]string{"b": "2"}}

    ds := DataSlice{a, b}

    for _, v := range ds {
        if value, ok := v.(DataA); ok {
            fmt.Printf("At%qn", GetDataX[DataA](value))
            continue
        }

        if value, ok := v.(DataB); ok {
            fmt.Printf("Bt%qn", GetDataX[DataB](value))
            continue
        }

        // add unknown type handling logic here
    }
}

首先，我简化了代码，仅考虑 dataa 和 datab 结构。然后，我将指针接收器更改为值接收器，因为您不会更改传递给方法的实际实例的状态。由于此更改，getdatax 可以成功工作，并且您可以获得所有类似结构的信息。

如果这能解决您的问题或者您需要其他东西，请告诉我，谢谢！