Wie kann Golangs dynamische Strukturtyprückgabe die Codeeffizienz verbessern und gleichzeitig Typsicherheitsrisiken verwalten?

Dynamische Strukturtyprückgabe in Golang

In Revel-Projekten kann es häufig zu erheblichen Redundanzen bei den Rückgabetypen verschiedener Modelle kommen.

Betrachten Sie diese beiden Funktionen:

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
}

Beide Funktionen geben denselben Datentyp zurück (Zeiger auf Slices von Strukturen). Um Redundanz zu reduzieren, besteht eine Idee darin, eine generische Rückgabefunktion zu erstellen, die eine Schnittstelle{} zurückgibt, die verschiedene Typen darstellen kann.

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

Mit diesem Ansatz gäbe es nur eine Rückgabefunktion, was den Code vereinfacht und reduziert Redundanz.

Es ist jedoch wichtig zu beachten, dass die Rückgabeschnittstelle{} im Lieferumfang enthalten ist Vorbehalte:

1. Verlust von Typinformationen: Der Compiler kann die Typsicherheit nicht mehr erzwingen, daher ist eine Umwandlung erforderlich, bevor der zurückgegebene Wert sicher verwendet werden kann.
2. Typwechsel und Zusicherungen: Beim Casting ist die Verwendung von Typwechseln oder Zusicherungen erforderlich, was zu zusätzlicher Komplexität und zusätzlichem Potenzial führen kann Fehler.

Das folgende Codebeispiel demonstriert diesen Ansatz:

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]
}

Das obige ist der detaillierte Inhalt vonWie kann Golangs dynamische Strukturtyprückgabe die Codeeffizienz verbessern und gleichzeitig Typsicherheitsrisiken verwalten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!