Inspecter les champs et balises des structs
Parcourir les champs et lire les balises des structs
Inspecter les champs et balises des structs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Type StructField
reflect.StructField décrit un champ d’une structure : Name, Type, Tag, Index, Offset, Anonymous et IsExported.
Parcours des champs
Parcourez tous les champs d’un type structure :
t := reflect.TypeOf(struct{ ID int; Name string }{})
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Println(f.Name, f.Type, f.IsExported())
}Lecture des balises de structure
Les balises sont accessibles via StructField.Tag.Get("key") :
type User struct {
ID int `json:"id" db:"user_id"`
Name string `json:"name,omitempty"`
}
f, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(f.Tag.Get("json")) // "name,omitempty"Analyse des options de balise
Les balises peuvent contenir des options séparées par des virgules. Analysez-les avec strings.Split :
tag := f.Tag.Get("json") // "name,omitempty"
parts := strings.Split(tag, ",")
name := parts[0] // "name"
omitempty := len(parts) > 1 && parts[1] == "omitempty"FieldByName et FieldByIndex
Recherchez un champ par son nom ou son index. FieldByName recherche les champs exportés dans la structure et les structures intégrées :
f, ok := reflect.TypeOf(User{}).FieldByName("Name")
if ok { fmt.Println(f.Tag.Get("json")) }Champs de structures intégrées
Pour les structures intégrées, Anonymous vaut true. Utilisez Type.FieldByIndex([]int{0,1}) pour accéder aux champs imbriqués.
Champs non exportés
Les champs non exportés (en minuscules) peuvent être inspectés pour connaître leur type et leur balise, mais leurs valeurs ne peuvent pas être lues ou définies par réflexion : une panique se produit.
Création d’un cache de champs
Analyser les balises de structure à chaque appel coûte cher. Mettez le résultat en cache dans une sync.Map indexée par reflect.Type :
var fieldCache sync.Map
func getFields(t reflect.Type) []fieldInfo {
if v, ok := fieldCache.Load(t); ok { return v.([]fieldInfo) }
fields := parseFields(t)
fieldCache.Store(t, fields)
return fields
}Cas d’utilisation : ORM simple
Parcourez tous les champs possédant une balise "db" afin de générer dynamiquement une liste de colonnes INSERT :
t := reflect.TypeOf(u)
v := reflect.ValueOf(u)
for i := 0; i < t.NumField(); i++ {
col := t.Field(i).Tag.Get("db")
val := v.Field(i).Interface()
// build query...
}Cas d’utilisation : chargeur de configuration
Parcourez les champs d’une structure possédant une balise "env" et renseignez-les à partir des variables d’environnement :
if env := f.Tag.Get("env"); env != "" {
if val := os.Getenv(env); val != "" {
v.Field(i).SetString(val)
}
}StructTag.Lookup
Tag.Lookup("key") renvoie la valeur de la balise et un booléen indiquant si la clé était présente, contrairement à Get, qui renvoie "" pour les clés absentes.
val, ok := f.Tag.Lookup("json")
if !ok { /* no json tag */ }Vérification rapide
Comment lire la valeur de la balise de structure "json" depuis un reflect.StructField ?
Récapitulatif : champs et balises de structure
Points clés :
- reflect.TypeOf → .NumField(), .Field(i) pour les métadonnées des champs
- StructField.Tag.Get("key") pour lire les valeurs des balises
- Mettre en cache les métadonnées des champs dans sync.Map pour éviter les analyses répétées
- Utiliser Tag.Lookup lorsqu’il est important de distinguer une balise absente d’une chaîne vide
Questions Fréquemment Posées
La leçon « Inspecter les champs et balises des structs » est-elle gratuite ?
Oui — le texte complet de « Inspecter les champs et balises des structs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Inspecter les champs et balises des structs » ?
Parcourir les champs et lire les balises des structs Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Inspecter les champs et balises des structs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- reflect.Type et reflect.Value
- Inspecter les champs et balises des structs
- Appels de fonctions dynamiques
- Réflexion pratique : sérialiseurs