Comment fonctionne l'inference de type pour les valeurs JSON ?

L'outil mappe les types JSON vers chaque langage : string → string/str/String, number (entier) → int/number/int/Integer, number (decimal) → float64/number/float/Double, boolean → bool/boolean/bool/Boolean, null → interface{}/unknown/Any/Object, array → []T/T[]/list[T]/List , object → struct/interface/classe imbriquee. Lorsqu'un tableau contient des types mixtes, un type union est genere.

JSON vers Struct / Interface / Classe | Go, TypeScript, Python, Java

← Retour aux outils de conversion

Collez le JSON

Tout objet ou tableau JSON

Nommez la racine

Defaut : "Root"

Copiez pour votre langage

Go, TS, Python ou Java

Nom racine :

Collez du JSON et cliquez sur Generer pour voir la sortie

Mappage des Types JSON — Comment chaque langage represente les types JSON

Type JSON	Exemple	Go	TypeScript	Python	Java
string	`"hello"`	`string`	`string`	`str`	`String`
integer	`42`	`int`	`number`	`int`	`Integer`
float	`3.14`	`float64`	`number`	`float`	`Double`
boolean	`true`	`bool`	`boolean`	`bool`	`Boolean`
null	`null`	`interface{}`	`unknown`	`Any`	`Object`
array	`[1,2,3]`	`[]T`	`T[]`	`list[T]`	`List<T>`
object	`{"a":1}`	`struct{...}`	`interface{...}`	`@dataclass class`	`class{...}`

Type JSON

Exemple

TypeScript

Python

Java

string

"hello"

string

str

String

integer

42

int

number

int

Integer

float

3.14

float64

number

float

Double

boolean

true

bool

boolean

bool

Boolean

null

null

interface{}

unknown

Any

Object

array

[1,2,3]

[]T

T[]

list[T]

List<T>

object

{"a":1}

struct{...}

interface{...}

@dataclass class

class{...}

Pourquoi generer des types a partir de JSON ?

L'integration d'API est le cas d'usage le plus courant : vous recevez une reponse JSON d'une API REST ou GraphQL et avez besoin de modeles types dans votre langage de predilection. Ecrire manuellement des definitions de struct a partir d'une grande reponse JSON est fastidieux et sujet aux erreurs — un objet JSON de 100 lignes peut prendre plus de 30 minutes a saisir a la main, et un seul type de champ incorrect provoque des erreurs d'execution. Les fichiers de configuration (package.json, terraform.tfstate, docker-compose.yml) sont une autre source frequente : les developpeurs veulent un acces type-safe aux donnees de configuration. Les pipelines de generation de code utilisent les outils JSON-vers-type comme premiere etape avant de generer du code de serialisation, des schemas de base de donnees ou de la documentation d'API. Cet outil genere les 4 sorties de langage a partir d'une seule entree JSON — sans inscription, sans cle API, resultats instantanes.

Conventions specifiques a chaque langage

Go : Les noms de champs utilisent PascalCase avec les balises de struct json:"nom_champ". Les champs de type string utilisent string ; les nombres sont par defaut float64 sauf s'ils sont clairement entiers. Les objets imbriques deviennent des types struct imbriques. La balise de struct preserve la cle JSON d'origine pour le marshaling/unmarshaling.

TypeScript : Les interfaces utilisent PascalCase (ex. Root, Address). Les champs optionnels (provenant de valeurs null) recoivent le modificateur ?. Les tableaux utilisent la syntaxe T[]. Les types union sont generes pour les tableaux avec des types d'elements mixtes.

Python : Utilise le decorateur @dataclass avec les annotations de type. Les champs recoivent Optional[T] pour les valeurs nullables. Les objets imbriques deviennent des classes dataclass imbriquees. Les imports from dataclasses import dataclass et from typing import List, Optional sont inclus.

Java : Genere des classes POJO (Plain Old Java Object) avec des champs prives, des getters/setters publics et des collections generiques appropriees. Utilise List<T> pour les tableaux, Integer/Double/Boolean pour les wrappers de types primitifs nullables.

Foire aux Questions

Comment convertir du JSON en Go struct ?

Collez votre JSON, passez a l'onglet Go. L'outil genere des structs Go appropriees avec les balises json:"...", les types struct imbriques et les types slice pour les tableaux. Les champs utilisent PascalCase avec la cle JSON d'origine preservee dans les balises de struct.

Comment generer des interfaces TypeScript a partir de JSON ?

Selectionnez l'onglet TypeScript apres avoir colle votre JSON. Les interfaces sont generees avec des modificateurs optionnels pour les champs nullables, les types tableau utilisant T[] et les interfaces imbriquees pour les objets imbriques.

Cela peut-il generer des Python dataclass ou Java class a partir de JSON ?

Oui — les 4 langages sont generes simultanement. Python : @dataclass avec annotations de type et Optional/List de typing. Java : POJO avec champs prives, getters/setters et collections generiques. Passez d'un onglet a l'autre pour voir chaque langage.

Comment fonctionne l'inference de type ?

Les valeurs JSON sont mappees : strings → string/str/String, entiers → int/number/int/Integer, decimaux → float64/number/float/Double, booleens → bool/boolean/bool/Boolean, null → interface{}/unknown/Any/Object, tableaux → collections typees, objets → types imbriques. Consultez le tableau de mappage des types ci-dessus.

Qu'en est-il des champs optionnels et des valeurs null ?

Les valeurs JSON null generent des types optionnels/pointeur : *T ou interface{} en Go, modificateur ? en TypeScript, Optional[T] en Python, wrappers nullables en Java. Les champs absents de certains elements d'un tableau sont traites comme optionnels dans toutes les sorties.