Réflexion pratique : sérialiseurs
Construire un sérialiseur simple semblable à JSON avec reflect
Réflexion pratique : sérialiseurs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.
Présentation d’un sérialiseur JSON personnalisé
Créer un sérialiseur personnalisé avec la réflexion illustre une utilisation pratique de celle-ci : parcourir les champs d’une structure, lire les balises, accéder aux valeurs et construire la sortie — c’est la même approche que celle utilisée en interne par encoding/json.
Conversion simple d’une structure en map
Convertissez une structure en map[string]any à l’aide de la réflexion :
func StructToMap(v any) map[string]any {
t := reflect.TypeOf(v)
val := reflect.ValueOf(v)
result := make(map[string]any, t.NumField())
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
if !f.IsExported() { continue }
key := f.Tag.Get("json")
if key == "" { key = f.Name }
result[key] = val.Field(i).Interface()
}
return result
}Gestion des pointeurs
Déréférencez les champs pointeurs avant de lire leurs valeurs :
fv := val.Field(i)
if fv.Kind() == reflect.Ptr {
if fv.IsNil() { continue }
fv = fv.Elem()
}Gestion des structures imbriquées
Traitez récursivement les champs des structures imbriquées :
if fv.Kind() == reflect.Struct {
result[key] = StructToMap(fv.Interface())
continue
}Prise en charge d’omitempty
Ignorez les champs dont la valeur est nulle si la balise contient "omitempty" :
if strings.Contains(tag, "omitempty") && fv.IsZero() { continue }Conversion map-structure (désérialisation)
Renseignez une structure à partir d’une map en faisant correspondre les clés de la map aux balises des champs :
func MapToStruct(m map[string]any, dest any) {
t := reflect.TypeOf(dest).Elem()
v := reflect.ValueOf(dest).Elem()
for i := 0; i < t.NumField(); i++ {
key := t.Field(i).Tag.Get("json")
if val, ok := m[key]; ok {
v.Field(i).Set(reflect.ValueOf(val))
}
}
}Conversion de types
Les valeurs provenant de JSON sont souvent de type float64 pour les nombres. Convertissez-les vers le type du champ cible lors de l’affectation :
if f.Type.Kind() == reflect.Int && reflect.TypeOf(val).Kind() == reflect.Float64 {
v.Field(i).SetInt(int64(val.(float64)))
}Mise en cache des métadonnées des champs
Mettez en cache la correspondance champ-balise dans une sync.Map indexée par reflect.Type afin d’éviter de répéter la réflexion à chaque appel de sérialisation.
Alternative par génération de code
Pour les chemins où les performances sont essentielles, générez des sérialiseurs spécifiques aux types avec des outils tels qu’easyjson ou ffjson. Ils évitent entièrement la réflexion lors de l’exécution.
Quand créer des sérialiseurs personnalisés
Les sérialiseurs personnalisés sont utiles pour les formats autres que JSON (BSON, Avro, CSV), les règles d’encodage personnalisées ou les exigences strictes en matière de performances. Pour la plupart des cas d’utilisation, encoding/json suffit.
Tester le sérialiseur
Test aller-retour : sérialisez une structure en table associative, désérialisez-la, puis vérifiez que les valeurs correspondent à l’originale :
u := User{Name: "Alice", Age: 30}
m := StructToMap(u)
var u2 User
MapToStruct(m, &u2)
assert.Equal(t, u, u2)Vérification rapide
Pourquoi la mise en cache des métadonnées des champs est-elle importante lors de la création d’un sérialiseur fondé sur la réflexion ?
Récapitulatif : sérialiseurs fondés sur la réflexion
Points clés :
- Itérez sur les champs avec NumField/Field ; lisez les balises avec Tag.Get
- Gérez les pointeurs, les structures imbriquées et les valeurs nulles
- Mettez en cache les métadonnées des champs dans sync.Map pour améliorer les performances
- Utilisez la génération de code pour obtenir le débit le plus élevé
Questions Fréquemment Posées
La leçon « Réflexion pratique : sérialiseurs » est-elle gratuite ?
Oui — le texte complet de « Réflexion pratique : sérialiseurs » 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 « Réflexion pratique : sérialiseurs » ?
Construire un sérialiseur simple semblable à JSON avec reflect 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 4 sur 4.
Combien de temps prend la leçon « Réflexion pratique : sérialiseurs » ?
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