Générateur de structures Go à partir de JSON
Générez des définitions de types `struct` en Go, accompagnées de tags `json`, à partir de données JSON. L'outil déduit les types Go à partir des valeurs JSON et crée des structures Go idiomatiques, prêtes à être utilisées avec le package `encoding/json`.
Génère des champs de struct Go avec les types appropriés et les tags de struct JSON.
Convertit les chaînes JSON en chaînes de caractères, les nombres en int64 ou float64 et les booléens en bool.
Crée des définitions de structures imbriquées pour des objets JSON imbriqués.
Utilise des noms de champs idiomatiques en PascalCase et des tags JSON en camelCase.
La sortie est prête à être utilisée avec Marshal et Unmarshal du package encoding/json.
Mode d'emploi
Collez un objet JSON dans le champ de saisie.
Le générateur déduit les types Go et produit des déclarations de struct.
Copiez les définitions de struct dans votre fichier source Go.
Importez encoding/json et utilisez la structure avec json.Unmarshal.
Développement d'API en Go
- Désérialiser les réponses de l'API REST
- Définir les types de requête et de réponse pour les gestionnaires HTTP
- Typage des fichiers de configuration JSON pour les services Go
Ingénierie des données
- Analyser les charges utiles d'événements JSON dans des workers Go
- Définir des structures de modèle de données à partir d'enregistrements d'exemple
- Typage des charges utiles de webhook pour les récepteurs Go
Écosystème Go
- net/http
- gin
- écho
- chi
- gRPC-gateway
- encoding/json
Ajoutez `omitempty` aux tags JSON pour les champs qui doivent être omis lorsqu'ils ont une valeur nulle : `json:"field,omitempty"`
Pour les champs JSON pouvant être nuls (valeurs nulles), utilisez des types pointeur (*string, *int64) afin de distinguer la valeur zéro de l'absence de valeur.
Si un nombre JSON peut être soit un entier, soit un nombre à virgule flottante, utilisez float64 pour éviter une perte de précision avec le package encoding/json de Go.
Utilisez des types pointeur (*string, *int64) pour les champs JSON pouvant être nuls, afin de distinguer correctement la valeur nulle des valeurs zéro.
Ajoutez `omitempty` aux tags JSON des champs facultatifs pour obtenir une sortie JSON sérialisée plus propre.
Pour le code de production, validez la structure générée par rapport à la spécification complète de l'API et ajoutez les champs supplémentaires susceptibles de ne pas figurer dans l'exemple JSON.
Foire aux questions
Trouvez des réponses aux questions fréquentes sur nos outils et services.
Comprendre JSON vers struct Go
Le système de typage statique de Go et le package `encoding/json` de sa bibliothèque standard font de la sérialisation JSON basée sur les tags de structure (*struct tags*) l'approche idiomatique pour la manipulation de données JSON dans les programmes Go. Chaque clé JSON correspond à un champ de structure doté d'un tag `json` spécifique, lequel définit le nom de la clé pour la sérialisation, le comportement optionnel `omitempty` et la conversion éventuelle en chaîne de caractères. Rédiger manuellement ces définitions de structures pour des charges utiles complexes issues d'API ou pour de volumineux fichiers de configuration JSON est une tâche fastidieuse et propice aux erreurs. Les développeurs commettent fréquemment des fautes de frappe dans les noms de champs, choisissent des types Go inappropriés ou oublient d'ajouter les tags de structure ; autant d'erreurs qui entraînent des échecs silencieux lors de la désérialisation JSON, difficiles à diagnostiquer. La génération automatique de structures Go à partir d'exemples JSON permet d'éliminer totalement ce type d'erreurs.
Les règles d'inférence de type pour la conversion de JSON vers Go reposent sur une correspondance directe entre le système de types JSON et les types primitifs et composés de Go. Les chaînes JSON deviennent des champs de type `string` en Go. Les valeurs booléennes JSON deviennent des booléens Go (`bool`). La valeur `null` de JSON constitue un cas particulier : comme les valeurs « zéro » de Go pour les chaînes, les entiers et les booléens (chaîne vide, 0, `false`) sont des valeurs valides entrant en conflit avec la notion d'absence propre à JSON, les champs JSON pouvant être nuls doivent être typés comme des pointeurs (`*string`, `*int64`, `*bool`) ; ainsi, un pointeur `nil` en Go représente correctement la valeur `null` de JSON, la distinguant de la valeur « zéro ». Les tableaux JSON deviennent des *slices* Go typées selon les éléments qu'elles contiennent (`[]string`, `[]int64`, `[]NestedStruct`). Les objets JSON deviennent des types *struct* imbriqués, chacun disposant de sa propre définition de structure.
Le package `encoding/json` de Go utilise des tags de structure pour contrôler le comportement de sérialisation (marshaling) et de désérialisation (unmarshaling). La syntaxe de tag `json:"keyname"` associe le champ de la structure à la clé JSON correspondante. Des options supplémentaires permettent d'affiner ce comportement : `json:"keyname,omitempty"` omet le champ lors de la sérialisation s'il contient sa valeur zéro, ce qui produit un JSON plus propre pour les champs facultatifs ; `json:"-"` entraîne l'ignorance totale du champ ; `json:"keyname,string"` force la conversion des valeurs numériques en chaînes JSON (et inversement). Le générateur produit le tag de base `keyname` pour chaque champ. Il incombe aux développeurs d'ajouter `omitempty` pour les champs facultatifs et d'utiliser des types pointeur pour les champs pouvant être nuls, conformément au contrat réel de l'API.
Ce générateur de structures Go à partir de JSON produit des définitions de structures idiomatiques, incluant des noms de champs exportés au format PascalCase, des types appropriés et des tags `json` précis reprenant les noms de clés JSON d'origine. Les objets JSON imbriqués sont extraits sous forme de types de structure nommés distincts, dans le respect des conventions de nommage de Go. Le code généré est immédiatement compilable une fois intégré dans un fichier source Go avec la déclaration de package adéquate ; il est compatible avec le package standard `encoding/json` ainsi qu'avec les bibliothèques JSON tierces populaires telles que `jsoniter` et `go-json`. Qu'il s'agisse de développer des clients API, de modéliser des données pour des microservices ou d'analyser des configurations en Go, cet outil réduit considérablement le temps de mise en place de nouvelles structures de données, passant de plusieurs minutes de travail manuel à quelques secondes de génération automatisée.