Comment le retour de type Struct dynamique de Golang peut-il améliorer l'efficacité du code tout en gérant les risques de sécurité des types ?

Retour de type Struct dynamique dans Golang

Dans les projets Revel, il peut souvent y avoir une redondance importante dans les types de retour entre différents modèles.

Considérez ces deux fonctions :

func (c Helper) Brands() []*models.Brand {
    // Select from rethinkdb and populate models.Brand
    var brands []*models.Brand
    rows.All(&brands)
    return brands
}

func (c Helper) BlogPosts() []*models.Post {
    // Select from rethinkdb and populate models.Post
    var posts []*models.Post
    rows.All(&posts)
    return posts
}

Les deux fonctions renvoient le même type de données (pointeurs vers des tranches de structures). Pour réduire la redondance, une idée est de créer une fonction de retour générique qui renvoie une interface{} capable de représenter différents types.

func (c Helper) ReturnModels(modelName string) interface{} {
    // Select from rethinkdb based on modelName and return interface{}
}

Avec cette approche, il n'y aurait qu'une seule fonction de retour, simplifiant le code et réduisant redondance.

Cependant, il est important de noter que le retour de l'interface{} est livré avec mises en garde :

1. Perte d'informations de type : Le compilateur ne sera plus en mesure d'appliquer la sécurité des types, un casting sera donc nécessaire avant d'utiliser la valeur renvoyée en toute sécurité.
2. Commutateurs de type et assertions : La diffusion nécessitera l'utilisation de commutateurs de type ou d'assertions, ce qui peut entraîner une complexité et un potentiel supplémentaires erreurs.

L'exemple de code suivant illustre cette approche :

package main

import "fmt"

type Post struct {
    Author  string
    Content string
}

type Brand struct {
    Name string
}

var database map[string]interface{}

func init() {
    database = make(map[string]interface{})

    brands := []Brand{
        {Name: "Gucci"},
        {Name: "LV"},
    }
    database["brands"] = brands

    posts := []Post{
        {Author: "J.K.R", Content: "Whatever"},
    }
    database["posts"] = posts
}

func main() {
    fmt.Println("List of Brands:")
    if brands, ok := ReturnModels("brands").([]Brand); ok {
        fmt.Printf("%v", brands)
    }

    fmt.Println("\nList of Posts:")
    if posts, ok := ReturnModels("posts").([]Post); ok {
        fmt.Printf("%v", posts)
    }
}

func ReturnModels(modelName string) interface{} {
    return database[modelName]
}

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!