Convertisseur Rust vers JSON
Colle tes structs Rust avec derive Serialize. Récupère du JSON propre.
Ce que fait cet outil
Si tu as déjà défini un struct, collé #[derive(Serialize)] dessus, et réalisé que tu voulais juste le JSON sans écrire le boilerplate serde, ajouter serde_json au Cargo.toml et lancer cargo run — cet outil fait exactement ça. Colle ton Rust ici et récupère du JSON valide sans toucher à cargo. Il gère un struct unique, un module entier avec plusieurs types, ou du code truffé de Vec et Option imbriqués — même résultat : un document JSON propre où chaque champ est préservé.
Le convertisseur suit la manière dont serde sérialise réellement les valeurs. String et &str deviennent des strings JSON. i32, u64, f32, f64 deviennent des nombres JSON. bool donne true/false. Vec<T>, &[T] et [T; N] deviennent des tableaux JSON. HashMap<String, V> / BTreeMap<String, V> deviennent des objets JSON. Option<T> avec None donne null en JSON ; avec Some(value), le type interne est sérialisé. Les tuples sortent sous forme de tableaux hétérogènes — comportement exact documenté sur serde.rs/data-model.
Les attributs serde sont respectés. #[serde(rename = "x")] renomme la clé JSON, #[serde(skip)] retire le champ et #[serde(flatten)] remonte les champs du struct imbriqué dans l'objet parent. Les enum suivent par défaut la représentation externally-tagged (configurable avec #[serde(tag = "type")]). Colle plusieurs structs d'un coup et chacun ressort comme entrée de premier niveau. Si tu bosses sur des services web basés sur la bibliothèque standard Rust plus axum/actix, cette sortie se pose directement dans tes tests d'intégration.
Comment l'utiliser
Trois étapes. Même fonctionnement que tu colles un struct ou un module entier avec une douzaine de types.
Colle ton Rust (ou charge l'exemple)
Balance ton Rust dans l'éditeur de gauche tel quel. Un struct, un tuple struct, un enum avec variantes, plusieurs types ou Vec/Option/HashMap imbriqués — tout passe. Clique sur Charger un exemple pour voir un cas réaliste.
Pas besoin d'enlever les use, les lifetimes ou les attributs derive. Laisse la syntaxe Rust telle quelle — les attributs serde font partie de ce que le parser lit.
Clique sur Convertir
Clique sur le bouton vert Convertir. L'outil lit le Rust, conserve chaque struct et chaque champ, et émet le JSON en un coup. Un petit indicateur de chargement tourne pendant le traitement.
Copie le JSON
Le panneau de droite se remplit de JSON indenté. Copie-le dans un test reqwest, un test d'intégration axum, tes exemples OpenAPI ou une commande curl. Aucune recompilation.
Quand ça sert vraiment
Fixtures pour services web
Tu as un struct de requête axum ou actix et il te faut le JSON pour un test ou un curl. Colle le struct, récupère le JSON, passe à la suite — pas de cycle cargo.
Modèles de config CLI
Une CLI clap avec un struct Config. Convertis-le en template JSON que les utilisateurs peuvent éditer, sans écrire une impl <code>Default</code> sur mesure juste pour la doc.
Seeds pour tests d'intégration
Transforme les structs de tes tests unitaires en fichiers JSON de seed pour tests d'intégration, serveurs mock ou fixtures de bases embarquées.
Doc qui suit le code
Génère des exemples JSON pour ton README ou ta spec OpenAPI directement depuis les vrais types Rust, pour que la doc arrête de dériver.
Questions fréquentes
J'ai besoin de serde et serde_json dans mon Cargo.toml ?
Pas pour cet outil — il tourne côté serveur et ne compile pas ton code. Pour un usage runtime dans ton app, serde avec la feature derive plus serde_json est le combo standard.
Il respecte #[serde(rename)], #[serde(skip)] et #[serde(flatten)] ?
Oui. #[serde(rename = "x")] renomme la clé JSON, #[serde(skip)] retire le champ de la sortie et #[serde(flatten)] remonte les champs du struct imbriqué dans le parent — conforme à la doc des attributs de champ serde.
Comment sont traités Option, Vec et HashMap ?
Option<T> avec None devient null en JSON ; avec Some(v), la valeur interne est sérialisée. Vec<T>, slices et tableaux deviennent des tableaux JSON. HashMap<String, V> et BTreeMap<String, V> deviennent des objets JSON ; les maps à clés non-string voient leurs clés converties en strings.
Et les enums à variantes ?
Par défaut, les variantes d'enum utilisent la représentation externally-tagged ({ "VariantName": {...} }). Les attributs #[serde(tag = "type")], #[serde(untagged)] et #[serde(content = "data")] basculent en internally-tagged, untagged ou adjacently-tagged — l'outil lit ces attributs et émet la sortie en conséquence.
Mon code est-il stocké ?
Ton code est envoyé au backend pour la conversion et n'est pas conservé — on ne log pas le payload. Relis du code sensible avant de le coller.
Et si le Rust utilise des lifetimes ou des génériques ?
Les lifetimes (&'a str) sont ignorés — JSON n'en a pas la notion. Les génériques concrétisés (Vec<User>) marchent. Les génériques non instanciés sortent en null. Les macros qui s'expandent en syntaxe réelle marchent ; celles qui dépendent d'un crate proc-macro non visible ici sont traitées comme opaques.
Autres outils qui peuvent te servir
Rust vers JSON n'est qu'une pièce du puzzle. Ceux-ci se combinent bien avec :