Comment convertir l'interface en type spécifié à l'aide de génériques

Contenu de la question

Il existe une déclaration d'interface et de nombreuses structures qui la mettent en œuvre

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...

comprend également datac,d,e...

Je vais mettre ça datax 结构实例存储到 type dataslice []datainterface

Maintenant, si je veux obtenir datax, je peux faire ceci :

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() .....

Apparemment, il y a beaucoup de code en double ici :

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

J'ai donc pensé pouvoir utiliser des génériques pour résoudre ce problème, puis j'ai défini cette fonction :

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

Mais une erreur s'est produite : impossible 类型断言：'*t' 未实现 'datainterface

Alors je veux savoir est-ce vraiment impossible ? Ou est-ce que cela peut être fait d'une autre manière ?

Bonne réponse

Vous devriez pouvoir utiliser le code suivant pour répondre à vos besoins :

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("A\t%q\n", GetDataX[DataA](value))
            continue
        }

        if value, ok := v.(DataB); ok {
            fmt.Printf("B\t%q\n", GetDataX[DataB](value))
            continue
        }

        // add unknown type handling logic here
    }
}

Tout d'abord, j'ai simplifié le code, en considérant seulement dataa 和 datab 结构。然后，我将指针接收器更改为值接收器，因为您不会更改传递给方法的实际实例的状态。由于此更改，getdatax qu'il fonctionne avec succès et que vous obtenez toutes les informations de structure similaires.

Si cela résout votre problème ou si vous avez besoin d'autre chose, faites-le-moi savoir, merci !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!