JSON vers Rust

Recommandations connexes

À propos de JSON vers Rust : transformer les données JSON en structures Rust compilables

Cas d'utilisation

• Intégration REST API : convertissez la réponse JSON renvoyée par le backend en struct Rust, utilisez avec reqwest + serde_json pour une analyse fortement typée des corps de requête et réponses HTTP
• Développement backend Actix-web : convertissez les exemples JSON de paramètres d'API en struct Rust, utilisez directement comme paramètre web::Json<T> ou modèle de réponse pour compiler et exécuter
• Développement backend axum : convertissez les paramètres JSON des gestionnaires axum en struct Rust, utilisez avec l'extracteur Json<T> pour traiter les corps de requête POST
• Définition d'interfaces de microservices : convertissez les exemples JSON de corps de requête de services gRPC/HTTP en types Rust, unifiez les définitions de modèles côté serveur à partager entre plusieurs équipes
• Développement d'outils CLI : convertissez les exemples JSON de fichiers de configuration en struct Rust, utilisez avec serde + clap pour analyser les arguments de ligne de commande et la configuration
• Projets WebAssembly : consommez fortement typé les données JSON transmises par le frontend JS côté Rust/WASM avec la struct générée, réduisez les erreurs de type à l'exécution
• Applications de bureau Tauri : convertissez le payload JSON d'invoke frontend en struct Rust, utilisez comme type de paramètre #[tauri::command]
• Analyse de données de scraping : convertissez les données JSON extraites de pages web en types Rust, évitez les oublis de champs dus à l'accès dynamique avec serde_json::Value
• Développement de jeux : convertissez les données JSON de configuration de niveaux, attributs de personnages en struct Rust, facilitez la lecture des ressources de configuration par des moteurs comme Bevy
• IoT et embarqué : convertissez les données JSON de capteurs rapportées par les appareils en types Rust, pour l'analyse et la validation des messages d'appareils périphériques (nécessite une adaptation no_std)
• Migration de base de données : convertissez les documents JSON exportés depuis MongoDB / PostgreSQL en modèles Rust, comme référence pour la définition d'entités Diesel / SQLx
• Blockchain/Web3 : convertissez les réponses JSON RPC on-chain en struct Rust, pour l'encapsulation de types de SDK comme solana-sdk / substrate
• Construction de données de test : convertissez les fixtures JSON réelles renvoyées par le backend en types Rust, effectuez des assertions structurées et des tests golden dans les tests unitaires
• Analyse structurée de journaux : convertissez les journaux JSON collectés par ELK / Loki / Vector en types Rust, facilitez le filtrage, les règles d'alerte et l'extraction de champs
• Migration de centre de configuration : convertissez les configurations JSON d'Apollo / Nacos / Consul en types Rust, pour le rechargement à chaud et la validation de configuration côté serveur
• Collaboration inter-langages : lors de l'intégration entre backend Rust et frontend TypeScript, convertissez le même JSON en struct Rust et interface TS pour maintenir la cohérence des deux côtés
• Maintenance de SDK open source : générez des modèles Rust à partir des exemples JSON de la documentation d'API amont, publiez rapidement un SDK client Rust (publication crates.io)
• Exemples pédagogiques Rust : dans les cours, convertissez des exemples JSON en struct, enseignez le processus de désérialisation Serde, les concepts de propriété et de cycle de vie
• Conversion de noms de champs : après conversion de réponses API JSON en snake_case en structures Rust, ajoutez manuellement #[serde(rename)] pour le mappage de champs afin de maintenir la cohérence du style de nommage

Comment utiliser

1. Collez le contenu JSON (objet ou tableau recommandé) dans l'éditeur de gauche, ou cliquez sur le bouton de téléchargement pour sélectionner un fichier .json / .txt, vous pouvez également cliquer sur « Sample » pour charger l'exemple chinois
2. Attendez 400 ms pour la conversion automatique, le code struct Rust généré s'affichera à droite (avec use serde et #[derive(Serialize, Deserialize)])
3. Si le format JSON est incorrect, un message d'erreur rouge s'affiche à droite, cliquez sur le bouton « Réparer JSON » pour corriger automatiquement les problèmes de syntaxe courants (virgules traînantes, guillemets simples, guillemets manquants, etc.)
4. Cliquez sur le bouton « Copier » pour coller le code Rust généré dans le répertoire src du projet Cargo, ou cliquez sur le bouton « Télécharger » pour sauvegarder en fichier .rs
5. Ajoutez les dépendances serde = { version = "1", features = ["derive"] } et serde_json = "1" dans Cargo.toml, puis exécutez cargo build pour valider la compilation
6. (Facultatif) Ajustez manuellement les types de champs selon les besoins métier (comme i64 → u32), ajoutez #[serde(rename)] pour gérer le mappage snake_case et camelCase, complétez les types sémantiques comme chrono::DateTime

Fonctionnalités

• Conversion locale dans le navigateur : l'analyse JSON et la génération de code Rust s'effectuent entièrement dans le navigateur via le Web Worker quicktype-core, aucune donnée n'est envoyée à un serveur
• Sortie Serde-ready : génère automatiquement use serde::{Serialize, Deserialize}; et #[derive(Serialize, Deserialize)], utilisable directement avec serde_json pour désérialiser des réponses API réelles
• Inférence de type intelligente : String pour chaînes, i64 pour entiers, f64 pour flottants, bool pour booléens, Vec<T> pour tableaux, struct indépendante pour objets imbriqués, Option<serde_json::Value> pour null
• Séparation automatique des objets imbriqués : les objets imbriqués génèrent des struct indépendantes nommées par capitalisation du nom de champ (address → Address), évite les définitions dupliquées, prend en charge l'imbrication de tout niveau
• Traitement automatique Vec et Option : les tableaux JSON sont uniformément convertis en Vec<T>, les valeurs null en Option<serde_json::Value>, réduit le travail de saisie manuelle des types
• Prêt à l'emploi Actix-web / axum / reqwest : la struct générée s'utilise directement pour les corps de requête de gestionnaires Web, les modèles de réponse de clients HTTP, les structures de données Tauri
• Conversion automatique avec anti-rebond de 400 ms : conversion dès le collage, aperçu du code Rust en temps réel à droite, évite les clics inutiles et les ralentissements avec les grands JSON
• Réparation d'erreurs JSON en un clic : corrige automatiquement les erreurs courantes comme virgules traînantes, guillemets simples, guillemets manquants, commentaires, continue la génération après réparation
• Copie et téléchargement : cliquez pour copier tout le code Rust dans le presse-papier, ou téléchargez en fichier .rs à placer directement dans le répertoire src d'un projet Cargo
• Historique localStorage : sauvegarde automatiquement les dernières entrées, permet une reprise rapide après actualisation ou fermeture accidentelle
• Colonnes réactives : édition JSON à gauche, code Rust à droite, prend en charge le redimensionnement des panneaux par glisser-déposer, adapté aux grands écrans et mobiles
• Données d'exemple + téléchargement de fichiers : exemple chinois intégré (avec address / company / tags imbriqués), prend en charge le glisser-déposer ou le clic pour téléverser des fichiers .json / .txt

Exemples de code

// Cargo.toml
// [dependencies]
// actix-web = "4"
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

// Généré automatiquement par cet outil (depuis JSON)
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateUserRequest {
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: i64,
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

// Gestionnaire Actix-web : paramètre JSON automatiquement désérialisé
async fn create_user(payload: web::Json<CreateUserRequest>) -> impl Responder {
    let req = payload.into_inner();
    let user = User {
        id: 1,
        name: req.name,
        email: req.email,
        age: req.age,
        tags: req.tags,
    };
    HttpResponse::Ok().json(user) // La réponse est également sérialisée avec serde_json
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/users", web::post().to(create_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

/*
 * Appel client :
 * curl -X POST http://127.0.0.1:8080/users \
 *   -H "Content-Type: application/json" \
 *   -d '{"name":"Alice","email":"alice@example.com","age":30,"tags":["rust","actix"]}'
 */

// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
// reqwest = { version = "0.12", features = ["json"] }

use axum::{routing::get, Json, Router};
use serde::{Deserialize, Serialize};

// Généré automatiquement par cet outil
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Address {
    city: String,
    zip: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User {
    id: i64,
    name: String,
    email: String,
    address: Address,
    tags: Vec<String>,
}

// Gestionnaire axum : retourne une réponse JSON
async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        name: "Alice".into(),
        email: "alice@example.com".into(),
        address: Address { city: "Beijing".into(), zip: "100000".into() },
        tags: vec!["rust".into(), "axum".into()],
    })
}

// Client reqwest : désérialise la réponse d'API distante
async fn fetch_user(url: &str) -> Result<User, reqwest::Error> {
    let user: User = reqwest::get(url).await?.json().await?;
    Ok(user)
}

#[tokio::main]
async fn main() {
    // Démarrer le service axum
    let app = Router::new().route("/user", get(get_user));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

/*
 * Accès après compilation :
 * curl http://127.0.0.1:8080/user
 * {"id":1,"name":"Alice","email":"alice@example.com",
 *  "address":{"city":"Beijing","zip":"100000"},
 *  "tags":["rust","axum"]}
 */

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct Article {
    #[serde(rename = "article_id")]
    pub article_id: i64,

    #[serde(rename = "title")]
    pub title: String,

    // JSON: "2026-07-08T10:00:00Z" → chrono::DateTime<Utc>
    #[serde(rename = "created_at")]
    pub created_at: DateTime<Utc>,

    #[serde(rename = "view_count")]
    pub view_count: i64,

    // Champs manquants utilisent Default::default()
    #[serde(rename = "summary", default)]
    pub summary: Option<String>,

    #[serde(rename = "tags")]
    pub tags: Vec<String>,
}

fn main() -> Result<(), serde_json::Error> {
    let json = r#"{
        "article_id": 42,
        "title": "Hello Rust",
        "created_at": "2026-07-08T10:00:00Z",
        "view_count": 1024,
        "tags": ["rust", "serde"]
    }"#;

    let article: Article = serde_json::from_str(json)?;
    println!("{:?}", article);
    // Article { article_id: 42, title: "Hello Rust",
    //   created_at: 2026-07-08 10:00:00 UTC, view_count: 1024, ... }

    // Sérialisation inverse : valeur Rust → chaîne JSON
    let s = serde_json::to_string(&article)?;
    println!("{}", s);
    Ok(())
}

/*
 * Dépendances Cargo.toml :
 * serde = { version = "1", features = ["derive"] }
 * serde_json = "1"
 * chrono = { version = "0.4", features = ["serde"] }
 */

// Cargo.toml
// [dependencies]
// tauri = { version = "2", features = [] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

use serde::{Deserialize, Serialize};

// Généré automatiquement par cet outil
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateNoteRequest {
    pub title: String,
    pub content: String,
    pub tags: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Note {
    pub id: i64,
    pub title: String,
    pub content: String,
    pub tags: Vec<String>,
    pub created_at: String, // Peut être modifié manuellement en chrono::DateTime<Utc>
}

// Commande Tauri : appelée par le frontend via invoke('create_note', payload)
#[tauri::command]
fn create_note(payload: CreateNoteRequest) -> Result<Note, String> {
    let note = Note {
        id: 1,
        title: payload.title,
        content: payload.content,
        tags: payload.tags,
        created_at: "2026-07-14T10:00:00Z".to_string(),
    };
    Ok(note)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![create_note])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

/*
 * Exemple d'appel frontend (TypeScript):
 *
 * import { invoke } from '@tauri-apps/api/core';
 * const note = await invoke<Note>('create_note', {
 *   payload: { title: 'Hello', content: 'World', tags: ['rust', 'tauri'] }
 * });
 */

Best Practices

FAQ

Dépannage

Glossaire

struct

Mot-clé Rust utilisé pour définir des types de données composites. Cet outil génère précisément des struct, par exemple pub struct User { id: i64, name: String }. Les champs sont publics par défaut (sans visibilité explicite ils sont private, le derive serde nécessite public).

Serde

Framework de sérialisation/désérialisation le plus populaire de l'écosystème Rust. Le code généré par cet outil s'associe à Serde via #[derive(Serialize, Deserialize)], permettant l'analyse avec de multiples formats comme serde_json, bincode, toml, postcard.

derive macro

Macro procédurale Rust, implémente automatiquement des trait pour un type. Le #[derive(Serialize, Deserialize)] généré par cet outil implémente automatiquement les traits de sérialisation et désérialisation de Serde, pas besoin d'écrire de bloc impl manuellement.

Vec<T>

Type tableau dynamique de la bibliothèque standard Rust. Cet outil mappe automatiquement les tableaux JSON en Vec<T>, par exemple un tableau de chaînes devient Vec<String>. Vec possède une mémoire allouée sur le tas, dont le cycle de vie est géré automatiquement par le compilateur Rust.

Option<T>

Type valeur optionnelle de la bibliothèque standard Rust, indique qu'une valeur peut ne pas exister. Cet outil mappe le null JSON vers Option<serde_json::Value>, vous pouvez également modifier manuellement en Option<String> ou d'autres types plus précis, consommable via .unwrap() ou le pattern matching.

Cargo

Système de build et gestionnaire de paquets officiel de Rust. Lors de l'utilisation du code généré par cet outil, déclarez les dépendances serde et serde_json dans Cargo.toml, et exécutez cargo build / cargo run pour compiler et exécuter.

serde_json

Crate de Serde spécialisé dans le traitement JSON. L'usage typique est serde_json::from_str::<User>(&json_string) ou serde_json::from_reader(reader) pour convertir une chaîne/flux d'octets JSON en la struct Rust générée, c'est la dépendance sous-jacente du traitement JSON d'Actix-web / axum.

Serialize

Trait de sérialisation de Serde, indique qu'un type peut être encodé en JSON ou autres formats. Cet outil en génère automatiquement l'implémentation via derive, utilisable avec serde_json::to_string(&user) pour reconvertir une valeur Rust en chaîne JSON.

Deserialize

Trait de désérialisation de Serde, indique qu'un type peut être décodé depuis JSON ou autres formats. Cet outil en génère automatiquement l'implémentation via derive, utilisé avec serde_json::from_str, c'est le cœur de la désérialisation des corps de requête HTTP, fichiers de configuration, payload de files de messages.

Propriété (Ownership)

Concept central de gestion mémoire de Rust. Les types générés par cet outil comme String, Vec<T> possèdent leurs données respectives, dont le cycle de vie est géré automatiquement par le compilateur Rust après désérialisation, pas de libération manuelle nécessaire, pas de GC, pas de surcoût à l'exécution.

#[serde(rename = "...")]

Attribut de renommage de champ de Serde. Quand les noms de champs JSON (comme user_name) ne correspondent pas au style de nommage Rust, cette annotation indique à Serde de faire correspondre le nom JSON d'origine lors de la désérialisation. Couramment utilisé pour les projets Rust en camelCase s'interfaçant avec des API backend en snake_case.

#[serde(default)]

Attribut de valeur par défaut de champ de Serde. Quand un champ est absent du JSON, Default::default() du type est appelé. Couramment utilisé pour les scénarios de rétrocompatibilité lors de l'ajout de champs dans les itérations de version, évite l'échec de désérialisation des vieux JSON.

quicktype-core

Bibliothèque sous-jacente d'inférence de type multilingue et de génération de code utilisée par cet outil, originellement implémentée en TypeScript, compilée en WebAssembly puis exécutée dans le navigateur via Web Worker, prend en charge plus de 20 langages cibles comme Rust / TypeScript / Go / Python.

Web Worker

Mécanisme de thread d'arrière-plan fourni par le navigateur, permet à JavaScript d'exécuter des calculs coûteux dans un thread indépendant sans bloquer le thread principal. Cet outil utilise Web Worker pour charger le WASM quicktype-core, évite le gel de la page lors de la conversion de grands JSON.

WebAssembly (WASM)

Format d'instructions binaire pouvant être généré par compilation depuis C/C++/Rust etc., exécutable dans le navigateur à une vitesse proche du natif. Le moteur central de cet outil quicktype-core est précisément compilé en WASM puis exécuté dans le navigateur.

chrono

Bibliothèque de dates et heures la plus populaire de l'écosystème Rust, fournit des types comme DateTime<Utc>, NaiveDate, avec la feature serde activée elle peut s'associer à Serde pour analyser automatiquement les chaînes de date ISO 8601. Couramment utilisée pour remplacer les champs de temps String générés par défaut par cet outil.

no_std

Mode de compilation Rust qui désactive la bibliothèque standard std et n'utilise que la bibliothèque centrale core, adapté aux scénarios à ressources limitées comme l'embarqué, noyaux WebAssembly, systèmes d'exploitation. serde fonctionne également en no_std (activation des features correspondantes).

tokio

Runtime asynchrone le plus populaire de l'écosystème Rust, dont dépendent des bibliothèques majeures comme axum, reqwest, tonic. Le code généré par cet outil doit souvent être associé à la macro #[tokio::main] pour démarrer le runtime dans les scénarios asynchrones.

Tableau de correspondance rapide JSON vers types Rust

L'outil infère automatiquement le type Rust correspondant selon le type de valeur JSON :

Explication de la structure du code Rust généré

Le code typique généré par quicktype-core pour Rust comprend les parties suivantes :

Intégration des frameworks Rust courants avec la struct générée par cet outil

La struct générée s'utilise directement dans les scénarios courants de l'écosystème Rust suivants :

Tableau de référence des attributs Serde courants

Cet outil ne génère par défaut que #[derive(Serialize, Deserialize)], mais en projet réel des annotations d'attributs supplémentaires sont souvent nécessaires pour s'adapter aux scénarios métier :

Privacy & Security

Toutes les opérations de cet outil JSON vers Rust s'effectuent entièrement localement dans votre navigateur : l'analyse JSON, la génération de code Rust et le téléchargement de fichiers sont tous exécutés côté client via le module WebAssembly quicktype-core, aucun contenu JSON, fichier téléchargé ou code généré n'est envoyé sur le réseau à un serveur quelconque. Le téléchargement de fichiers utilise l'API native FileReader du navigateur pour lire directement en mémoire, sans passer par aucun service intermédiaire. Pas de suivi par Cookie, aucune saisie utilisateur ou donnée d'utilisation n'est collectée. Après fermeture ou actualisation de la page, tous les contenus d'entrée et de sortie sont automatiquement effacés de la mémoire. Convient au traitement de JSON contenant des clés API, tokens, données de confidentialité utilisateur, structures métier non lancées, champs d'interfaces internes.

Authoritative References

• SerdeDocumentation officielle Serde - Page d'accueil du framework de sérialisation
• SerdeDocumentation complète des macros dérivées et attributs Serde
• docs.rsDocumentation du crate serde_json (docs.rs)
• RustThe Book officiel Rust - Chapitre sur les structures
• ActixDocumentation officielle actix-web - Traitement JSON
• axumDocumentation officielle axum - Json extractor
• GlideDépôt GitHub quicktype-core