Golang interface de struct

J'ai une fonction qui a un paramètre du type d'interface{}, quelque chose comme:

func LoadTemplate(templateData interface{}) {

Dans mon cas, templateData est un struct, mais à chaque fois il a une structure différente. J'ai utilisé le type "{}", car il me permet d'envoyer toutes sortes de données.

Je suis en utilisant ce templateData pour envoyer les données au modèle:

err := tmpl.ExecuteTemplate(w, baseTemplateName, templateData)

Mais maintenant, je veux ajouter des nouvelles données et je ne sais pas comment le faire parce que l ' "interface" type ne m'autorise pas à ajouter/ajouter quoi que ce soit.

J'ai essayé de convertir l'interface d'une structure, mais je ne sais pas comment faire pour ajouter des données à une structure avec une structure inconnue.

Si j'utilise la fonction suivante, je vois l'interface de données:

templateData = appendAssetsToTemplateData(templateData)

func appendAssetsToTemplateData(t interface{}) interface{} {
    switch reflect.TypeOf(t).Kind() {
    case reflect.Struct:
        fmt.Println("struct")
        s := reflect.ValueOf(t)
        fmt.Println(s)

        //create a new struct based on current interface data
    }

    return t
}

Aucune idée de comment puis-je ajouter un enfant à l'interface initiale du paramètre (templateData)? Ou comment puis-je le transformer en une structure ou quelque chose d'autre afin d'ajouter de nouvelles enfant/données?

Merci de poster une solution, une réponse, non pas comme une mise à jour de la question. Si la réponse que vous avez utilisé est une autre question, merci de les signaler à cette question comme un double à l'autre question. Si c'est non, et c'est différent s'il vous plaît envoyer la bonne réponse détaillée pour aider les futurs visiteurs et pour éviter toute confusion. Je vous remercie.

OriginalL'auteur Pascut | 2017-06-28

go interface struct

10

Adrian est correct. Pour aller un peu plus loin, vous ne pouvez rien faire avec les interfaces si vous connaissez le type qui implémente cette interface. L'interface vide, interface{} n'est pas vraiment un "quelque chose" valeur comme est souvent mal compris; c'est juste une interface qui est immédiatement satisfait par tous les types.

Par conséquent, vous ne pouvez obtenir les valeurs de celle-ci ou de créer une nouvelle "interface" avec des valeurs ajoutées, en connaissant le type de satisfaire à l'interface vide avant et après l'ajout.

Le plus proche, vous pouvez arriver à faire ce que vous voulez, étant donné le typage statique, est en intégrant l'avant de taper dans l'après-type, de sorte que tout sera toujours possible d'accéder à la racine de l'après-type. L'exemple suivant illustre cette.

https://play.golang.org/p/JdF7Uevlqp
```
package main

import (
    "fmt"
)

type Before struct {
    m map[string]string
}

type After struct {
    Before
    s []string
}

func contrivedAfter(b interface{}) interface{} {
    return After{b.(Before), []string{"new value"}}
}

func main() {
    b := Before{map[string]string{"some": "value"}}
    a := contrivedAfter(b).(After)
    fmt.Println(a.m)
    fmt.Println(a.s)
}
```
En outre, étant donné que les données que vous passez à la modèle ne vous oblige pas à spécifier le type, vous pouvez utiliser un anonyme struct pour accomplir quelque chose de très similaire.

https://play.golang.org/p/3KUfHULR84
```
package main

import (
    "fmt"
)

type Before struct {
    m map[string]string
}

func contrivedAfter(b interface{}) interface{} {
    return struct{
        Before
        s []string
    }{b.(Before), []string{"new value"}}
}

func main() {
    b := Before{map[string]string{"some": "value"}}
    a := contrivedAfter(b)
    fmt.Println(a)
}
```
Ces exemples m'a aidé à résoudre le problème. Merci.

OriginalL'auteur TheHerk
4

Vous ne pouvez pas ajouter de données arbitrairement à une structure (struct); ils sont statiquement typé. Vous ne pouvez affecter des valeurs pour les champs définis pour le type struct. Votre meilleur pari est probablement d'utiliser un map place des structures pour cela.

vous avez raison, merci

OriginalL'auteur Adrian

Pas recommandée, mais vous pouvez créer les structures de manière dynamique à l'aide de l'reflètent paquet.

Voici un exemple:

package principal

import (
    "encoding/json"
    "os"
    "reflect"
)

type S struct {
    Name string
}

type D struct {
    Pants bool
}

func main() {
    a := Combine(&S{"Bob"}, &D{true})
    json.NewEncoder(os.Stderr).Encode(a)
}

func Combine(v ...interface{}) interface{} {
    f := make([]reflect.StructField, len(v))
    for i, u := range v {
        f[i].Type = reflect.TypeOf(u)
        f[i].Anonymous = true
    }

    r := reflect.New(reflect.StructOf(f)).Elem()
    for i, u := range v {
        r.Field(i).Set(reflect.ValueOf(u))
    }
    return r.Addr().Interface()
}

Vous pouvez utiliser quelque chose comme le Combine la fonction ci-dessus pour shmush n'importe quel nombre de structs ensemble. Malheureusement, à partir de la la documentation:

StructOf actuellement ne permet pas de générer les méthodes de wrapper pour les champs. Cette limitation peut être levée dans une future version.

Donc créé struct de ne pas hériter des méthodes de l'embarqué types. Encore, peut-être que c'est ce dont vous avez besoin.

OriginalL'auteur chowey

Si vous êtes simplement à la recherche pour convertir votre interface de struct, l'utilisation de cette méthode.

type Customer struct {
    Name string `json:"name"`
}

func main() {
    //create a customer, add it to DTO object and marshal it
    receivedData := somefunc() //returns interface

    //Attempt to unmarshall our customer
    receivedCustomer := getCustomerFromDTO(receivedData)
    fmt.Println(receivedCustomer)
}

func getCustomerFromDTO(data interface{}) Customer {
    m := data.(map[string]interface{})
    customer := Customer{}
    if name, ok := m["name"].(string); ok {
        customer.Name = name
    }
    return customer
}

OriginalL'auteur user8202594

Vous devez vous connecter pour publier un commentaire.