Aller au contenu

JSON vers TypeScript

JSON to TypeScript

Déduit des interfaces ou des types TypeScript à partir d’un échantillon JSON, en fusionnant les champs facultatifs et les unions.

Collez une réponse JSON et obtenez les interfaces TypeScript correspondantes. L'inférence fusionne tous les enregistrements de l'échantillon au lieu de lire le premier : un champ qui n'apparaît que dans certains d'entre eux ressort facultatif plutôt qu'obligatoire — c'est la différence entre un type qui compile et un type qui est vrai.

🔒 Fonctionne entièrement dans votre navigateurtypescriptjsoncodegentypes
Produire

JSON d’exemple

Déposez un fichier .json

Lu dans cet onglet. Rien n’est envoyé.

Donnez-lui tous les éléments dont vous disposez. Chaque enregistrement supplémentaire resserre la déduction : un champ absent de l’un d’eux est précisément ce qui le rend facultatif.

TypeScript

Comment s’en servir

  1. Collez autant d'enregistrements que vous en avez

    Chaque élément de chaque tableau est lu et fusionné, pas seulement le premier. Trois enregistrements en disent bien plus qu'un seul, car un champ absent de l'un d'eux est précisément ce qui rend ce champ facultatif.

  2. Nommez le type racine

    Les objets imbriqués sont nommés d'après la clé qui les porte, mise au singulier pour les tableaux : `users` donne donc un `User`. Seule la racine attend un nom de votre part.

  3. Lisez les décomptes sous la sortie

    Types, champs facultatifs, unions et nombre d'enregistrements fusionnés. Un décompte d'unions supérieur à zéro signifie qu'un champ portait deux sortes de valeurs différentes dans votre échantillon — cela vaut la peine d'y regarder avant de coller le résultat dans une base de code.

  4. Copiez les interfaces

    La sortie est un jeu d'interfaces exportées dans l'ordre de déclaration, prêtes à être collées dans un `.d.ts` ou à côté du fetch qui les renvoie.

Questions fréquentes

Est-ce un validateur ?

Non. Les types TypeScript sont effacés à la compilation : rien ici ne vérifie la réponse à l'exécution — un serveur qui change de forme vous remettra une valeur qui ment sur son type. S'il vous faut cette vérification, générez du Zod depuis le même écran et analysez avec.

Pourquoi un champ est-il typé `string` alors que c'est une date ?

Parce qu'en JSON, c'est une chaîne. L'inférence est structurelle — elle rapporte ce que sont les valeurs et ne devine pas qu'une chaîne qui ressemble à de l'ISO 8601 devrait devenir un `Date`. Restreindre cela est une décision qui porte sur votre base de code, pas sur l'échantillon.

Et si un champ est tantôt une chaîne, tantôt un nombre ?

Il devient une union, `string | number`, et le décompte d'unions en bas augmente. C'est en général un signal sur l'API plutôt que sur le type — un champ qui change de nature est un bug qui attend quelque part en aval.

Des types littéraux sont-ils produits à partir de l'échantillon ?

Non — un `status` qui vaut toujours `"active"` dans trois enregistrements ressort quand même en `string`. Trois enregistrements ne prouvent pas une énumération, et un type littéral inféré à partir de trop peu de données est le genre de chose qui casse une compilation une semaine plus tard.

À alimenter depuis

Ensuite

Ces outils acceptent ce que celui-ci produit : le résultat peut y aller directement.