JSON en Rust Struct en Ligne

Génère des structs Rust avec serde depuis un JSON, gratuit, dans ton navigateur.

Class name:

JSON

Rust Struct

#[derive(Serialize, Deserialize)]
pub struct Address {
    pub city: String,
    pub zip: String,
}

#[derive(Serialize, Deserialize)]
pub struct User {
    pub name: String,
    pub age: i64,
    pub skills: Vec<String>,
    pub address: Address,
}

Processed in your browser

À quoi ça sert

De JSON à Rust Struct avec serde

Compatible avec l'écosystème serde

Génère des structs prêts à utiliser avec serde_json, reqwest, Actix-web, Axum et n'importe quel crate de l'écosystème Rust.

100 % privé

Ton JSON ne quitte jamais ton navigateur. Aucune inscription, aucune télémétrie, aucun envoi à des serveurs.

Conventions Rust correctes

snake_case automatique, Option<T> pour les nullables, types numériques corrects (i64, f64). Code idiomatique.

Instantané

Structs générés en temps réel. Aucun bouton, aucune attente, aucune limite.

Comment ça marche

Trois étapes, sans complications

Colle ton JSON

Colle le JSON à modéliser. Ça peut être un objet imbriqué, un tableau ou n'importe quelle structure JSON valide.

Génération instantanée

L'outil génère automatiquement des structs Rust avec les dérivations serde, en respectant les conventions snake_case.

Copie le code

Copie le code généré et ajoute la dépendance serde dans ton Cargo.toml pour l'utiliser directement.

FAQ

Des questions ?

Qu'est-ce que serde ?

serde (serialization/deserialization) est le framework de sérialisation le plus populaire de l'écosystème Rust. Il convertit des structs Rust vers et depuis des formats comme JSON, YAML, TOML, MessagePack, CBOR et bien d'autres. La clé de serde est qu'il utilise des macros à la compilation, ce qui signifie un overhead nul à l'exécution : le code généré est aussi efficace que si tu avais écrit la sérialisation manuellement.

À quoi sert la macro #[derive] ?

La macro #[derive(Serialize, Deserialize)] en Rust indique au compilateur de générer automatiquement l'implémentation des traits Serialize et Deserialize de serde pour le struct. Cela élimine le besoin d'écrire du code de sérialisation manuellement. C'est équivalent à implémenter une interface, mais le code est généré à la compilation via des macros procédurales.

Pourquoi le snake_case est-il utilisé en Rust ?

Le snake_case est la convention de nommage officielle de Rust pour les variables, les champs de structs et les fonctions (définie dans les Rust API Guidelines). Cependant, les API REST retournent souvent du JSON en camelCase. serde gère cette incompatibilité automatiquement avec l'attribut #[serde(rename_all = "camelCase")] au niveau du struct, ou #[serde(rename = "fieldName")] par champ individuel.

Comment les champs nullable sont-ils gérés ?

En Rust, il n'existe pas de null — on utilise à la place le type Option<T>, qui peut être Some(valeur) ou None. Quand un champ JSON peut être null ou absent, le type Rust correspondant est Option<T>, par exemple Option<String> ou Option<i64>. serde désérialise automatiquement null comme None et ignore les champs avec None lors de la sérialisation (avec #[serde(skip_serializing_if = "Option::is_none")]).

Comment ajouter serde à mon projet ?

Ajoute ces lignes à ton Cargo.toml : serde = { version = "1.0", features = ["derive"] } et serde_json = "1.0". La feature "derive" active les macros #[derive(Serialize, Deserialize)]. serde_json fournit serde_json::from_str() pour la désérialisation et serde_json::to_string() pour la sérialisation. Ce sont parmi les crates les plus téléchargés de l'écosystème Rust.