Générateur de code depuis JSON

Qu’est-ce qu’un générateur de code depuis JSON ?#

Un générateur de code depuis JSON lit un exemple de document JSON, détermine la forme des données — quels champs sont des chaînes, quels sont des nombres, quels sont des objets imbriqués, quels sont des tableaux de quoi — et écrit les types d’entités qu’un vrai programme utiliserait pour porter ces données. Au lieu de coder à la main une interface TypeScript, une classe Java, une structure Go ou une classe C# pour coller à une réponse d’API, vous collez un exemple de réponse et vous obtenez des types prêts à déposer dans votre projet.

Sous le capot, il parcourt la valeur analysée et infère un schéma. Les objets imbriqués deviennent leur propre type nommé ; le type d’élément d’un tableau est la fusion de la forme de chaque élément (donc une liste d’objets qui n’ont pas tous les mêmes clés produit tout de même un seul type avec l’union des champs). Les noms de champs qui ne sont pas des identifiants valides — une clé avec trait d’union comme first-name, ou commençant par un chiffre — sont transformés en un identifiant légal et la clé d’origine est conservée comme annotation de sérialisation, de sorte que l’aller-retour continue de fonctionner.

La sortie est du code source en texte brut, sans aucune dépendance d’exécution à cette page. Copiez-le, collez-le dans votre base de code, ajustez les noms de types, et vous avez un point de départ — pas un modèle terminé, mais l’ossature ennuyeuse déjà écrite pour vous.

Mode d’emploi#

1. Choisissez la cible avec la liste déroulante Langage : TypeScript, Java, Go ou C#.
2. Renseignez le Nom racine (par défaut Root). Il devient le nom du type extérieur — par exemple User, Order, Response.
3. Collez votre JSON dans le panneau de gauche. Le code généré apparaît en direct à droite ; la ligne d’état signale les erreurs (JSON invalide, entrée vide).
4. Cliquez sur Copier pour placer le code dans le presse-papiers.
5. Exemple charge un objet imbriqué avec un sous-objet et un tableau ; Effacer réinitialise les deux panneaux.

Principales fonctionnalités#

• Quatre langages cibles. Interfaces TypeScript, classes Java, structures Go et classes C# — une entrée, quatre sorties, basculées par une liste déroulante.
• Inférence de schéma, pas typage littéral. Les objets imbriqués deviennent des types nommés ; les tableaux d’objets produisent un type d’élément nommé plutôt qu’une liste opaque any.
• Fusion de tableaux hétérogènes. Quand les éléments d’un tableau ont des champs différents, le type inféré est l’union — utile pour des réponses réelles désordonnées où aucun élément n’a toutes les clés.
• Identifiants sûrs, clés fidèles. Les clés qui ne sont pas des identifiants valides sont transformées, et la clé d’origine est conservée comme annotation de sérialisation (@JsonProperty, une étiquette Go json:, JsonPropertyName), donc le JSON d’origine se désérialise toujours correctement.
• En direct et local. La génération s’exécute dans votre navigateur au fil de la frappe ou des options ; les données ne quittent jamais la page.

Exemple détaillé#

Chargez Exemple avec Langage réglé sur TypeScript et Nom racine Root, et l’entrée est :

{
  "id": 1,
  "name": "Ada",
  "active": true,
  "address": { "city": "London", "zip": "NW1" },
  "tags": ["math", "logic"]
}

Le générateur émet deux interfaces — la racine, et un type Address nommé pour l’objet imbriqué :

export interface Root {
  id: number;
  name: string;
  active: boolean;
  address: Address;
  tags: Array<string>;
}

export interface Address {
  city: string;
  zip: string;
}

Basculez le langage sur Go et la même entrée devient des structs avec des étiquettes json: qui préservent les clés d’origine :

package model

type Root struct {
  Id       float64   `json:"id"`
  Name     string    `json:"name"`
  Active   bool      `json:"active"`
  Address  Address   `json:"address"`
  Tags     []string  `json:"tags"`
}

type Address struct {
  City  string  `json:"city"`
  Zip   string  `json:"zip"`
}

Notez comment id, un nombre JSON, atterrit comme number en TypeScript et float64 en Go — le générateur ne devine pas entier contre flottant, parce que le JSON lui-même ne les distingue pas.

FAQ#

Pourquoi mon champ entier est-il typé float64 / Double / double ?#

Parce que le JSON a un seul type nombre et aucun moyen de distinguer 5 de 5.0. Le générateur mappe chaque nombre JSON au type numérique général du langage cible — number en TypeScript, Double en Java, float64 en Go, double en C# — de sorte que le type soit toujours assez large pour porter n’importe quelle valeur. Si vous savez qu’un champ est toujours un entier, rétrécissez-le à la main en int / Long / int64 ensuite.

Que se passe-t-il quand les objets de mon tableau n’ont pas tous les mêmes champs ?#

Leurs formes sont fusionnées. Un tableau comme [{ "a": 1 }, { "a": 2, "b": "x" }] produit un seul type d’élément avec à la fois a et b, donc un seul type couvre chaque élément. Si deux éléments sont en désaccord sur le type d’un champ de manière incompatible (un nombre ici, une chaîne là), ce champ dégénère en any / Object plutôt que de choisir un côté et de se tromper sur l’autre.

Un champ de mon JSON a un trait d’union, comme first-name. Est-ce que ça va casser ?#

Non. Le générateur transforme first-name en un identifiant légal (firstName) pour le nom du champ et émet une annotation de sérialisation qui enregistre la clé d’origine — @JsonProperty("first-name") en Java, une étiquette json:"first-name" en Go, [JsonPropertyName("first-name")] en C#, et une clé "first-name" entre guillemets en TypeScript. Le code généré désérialise donc le JSON d’origine inchangé.

Que fait-il avec une valeur null ?#

Un champ dont la valeur est null est traité comme de type inconnu. En TypeScript, il devient un any optionnel (field?: any;) ; en Java et C#, il devient Object / object ; en Go, interface{}. C’est un signal délibéré — null ne vous dit rien sur ce que contient le champ quand il est présent, donc le générateur refuse de deviner et vous laisse le soin de le remplir.