JSON Swiss

JSON Swiss

Générateur JSON vers Rust

Entrée JSON

Chargement de l’éditeur…

Rust Généré

Configuration

Saisissez du JSON pour générer des structs Rust

Structs sûrs avec ownership

Comment convertir JSON en Rust – guide étape par étape

Utilisez ce générateur JSON vers Rust pour créer des structures Rust à partir d'échantillons JSON pour les services et les outils CLI avec prise en charge de Serde.

  1. Étape 1 – Collez un échantillon JSON

    • Collez un objet ou un tableau JSON représentatif dans l'éditeur de gauche.
    • Incluez des objets imbriqués, des tableaux et des champs nullables afin que les types soient correctement déduits.
    • Utilisez Import pour charger JSON à partir d'un fichier, d'une URL ou d'un exemple de données.

  2. Étape 2 – Choisissez les options de structure Rust

    • Définissez une racine Struct Name (par exemple Root).
    • Décidez comment gérer les champs facultatifs (Option<T>) et les valeurs inconnues (serde_json::Value).
    • Confirmez les attributs de dénomination et de serde afin que les clés JSON soient correctement mappées.

  3. Étape 3 – Vérifiez le code généré

    • Vérifiez les noms de champs, les types et la façon dont les tableaux/objets sont modélisés.
    • Ajustez les options telles que Root Type Name, la gestion des valeurs nulles et les frameworks si disponibles.
    • Si un champ est déduit de manière incorrecte, modifiez votre exemple JSON et régénérez-le.

  4. Étape 4 – Utiliser les structures avec serde

    • Ajoutez serde et serde_json à vos dépendances et activez les macros dérivées.
    • Désérialisez JSON dans votre structure racine en utilisant serde_json::from_str.
    • Ajoutez une validation après la désérialisation lorsque vous avez besoin de garanties plus solides.

  5. Étape 5 – Copier ou télécharger

    • Copiez la sortie dans votre projet ou téléchargez-la sous forme de fichier.
    • Exécutez votre formateur/linter pour qu'il corresponde à votre style de code.
    • Ajoutez des bibliothèques d'analyse/sérialisation JSON si votre langage l'exige.

Conseils rapides

  • Utilisez Option<T> pour les champs qui peuvent être manquants ou nuls.
  • Préférez les types chrono uniquement lorsque votre format d'horodatage est stable.
  • Gardez les structures DTO séparées des types de domaines internes pour plus de flexibilité.
Exemple de résultat (simplifié)
// Entrée JSON
{
  "id": 123,
  "name": "Maeve Winters",
  "email": "[email protected]",
  "active": true,
  "roles": ["admin", "editor"],
  "metadata": { "plan": "pro" },
  "createdAt": "2024-03-01T10:15:00Z",
  "score": 99.5,
  "notes": null
}

// Generated Rust structs (simplified)
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct Metadata {
  pub plan: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
  pub id: i64,
  pub name: String,
  pub email: Option<String>,
  pub active: bool,
  pub roles: Vec<String>,
  pub metadata: Metadata,
  pub created_at: String,
  pub score: f64,
  pub notes: serde_json::Value,
}

Outils JSON et Rust associés

Explorez d'autres outils JSON et de schéma qui fonctionnent parfaitement avec ce générateur JSON vers Rust.

Rust Struct vers JSON et schéma JSON

Convertissez les structures Rust existantes en exemples JSON et en schéma JSON pour la documentation et la validation.

Générateur de schéma JSON

Générez un schéma JSON à partir d'échantillons JSON pour valider les charges utiles et les contrats.

Formateur et validateur JSON

Formatez et validez JSON avant de générer des structures pour éviter les problèmes d'exécution.

Générateur JSON à emporter

Générez des structures Go lorsque vous gérez également les services Go.

Questions fréquentes

Quelles fonctionnalités Rust sont prises en charge ?

Le générateur crée des structs Rust avec ownership correct, prend en charge Serde, et suit les conventions Rust avec garanties de sécurité mémoire.

Puis‑je générer des structs compatibles Serde ?

Oui ! Sélectionnez « Serde » pour générer des structs avec #[derive(Serialize, Deserialize)] pour une sérialisation JSON automatique via serde.

Comment le Option handling fonctionne‑t‑il ?

Le générateur Rust utilise Option<T> par défaut pour les champs nullables, garantissant un traitement explicite du null et la sécurité mémoire.

Et pour borrowing et lifetimes ?

Les structs générés utilisent des types possédés (String plutôt que &str) pour éviter la complexité des lifetimes, tout en conservant les garanties de sûreté de Rust.

Générateur JSON vers Rust | JSONSwiss