Recherche de types de packages exportés dynamiquement

Contrairement aux capacités de découverte de type limité dans le package de réflect, cet article explore des méthodes alternatives pour découvrir tous les types de packages (en particulier les structures) à Runtime. Plus tard)

Dans Go 1.5 et les versions suivantes, les packages Types et importateurs introduisent un moyen puissant d'inspecter les packages. Voici comment vous pouvez les utiliser:

import ( "FMT" "Allez / importateur" ) func main () { pkg, err: = importor.default (). import ("time") Si err! = Nil { fmt.printf ("Erreur:% s \ n", err.Error ()) retour } pour _, Decrname: = range pkg.scope (). names () { fmt.println (Decname) } }

import (
    "fmt"
    "go/importer"
)

func main() {
    pkg, err := importer.Default().Import("time")
    if err != nil {
        fmt.Printf("error: %s\n", err.Error())
        return
    }
    for _, declName := range pkg.Scope().Names() {
        fmt.Println(declName)
    }
}

Avant la version 1.5, le package AST peut être utilisé pour analyser et inspecter le code source pour la découverte de type. Cependant, cette approche est plus complexe et peut nécessiter un code d'analyse supplémentaire.

Exemple de cas d'utilisation

Cette capacité de découverte de type peut être utilisée dans divers scénarios. Par exemple, dans un utilitaire de génération de code, il permet d'identifier les types qui intègrent un type spécifié. Cela permet la création de fonctions de test basées sur des types découverts sans exiger des étapes de régénération manuelle.

Conclusion

Malgré le manque de découverte de type natif dans le package de réflect, Go fournit des méthodes alternatives pour examiner les types de packages à Runtime. Cela permet une introspection de type plus flexible et peut être exploité dans diverses applications, y compris la génération de code et les cadres de test.