Travailler avec JSON en Rust : parsing et sérialisation en pratique

Introduction : pourquoi JSON est-il important en Rust ?

JSON (JavaScript Object Notation) reste l'un des formats les plus populaires pour l'échange de données entre services, fichiers de configuration et API. Dans l'écosystème Rust, le travail avec JSON est implémenté via le puissant crate serde_json, qui, associé au framework serde, offre une manière élégante et sécurisée de transformer les structures de données.

Contrairement aux langages dynamiques, Rust exige une description explicite des types, ce qui peut sembler complexe à première vue. Cependant, en pratique, cela offre une fiabilité incroyable : vous ne rencontrerez jamais un null inattendu ou un champ avec un type incorrect lors de l'exécution. Dans cet article, nous aborderons le parsing (désérialisation) et la sérialisation JSON à l'aide d'exemples concrets que vous pouvez appliquer immédiatement dans des projets réels.

1. Configuration du projet et installation des dépendances

Avant d'écrire du code, ajoutons les crates nécessaires dans Cargo.toml :

[dependencies]\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"

Le crate serde avec le flag derive permet de générer automatiquement le code pour la sérialisation et la désérialisation de nos structures. serde_json est responsable de la conversion vers/depuis JSON.

Importons tout le nécessaire dans main.rs :

use serde::{Deserialize, Serialize};\nuse serde_json::Result;

2. Sérialisation : transformer une structure Rust en JSON

La sérialisation est le processus de conversion d'un objet Rust en une chaîne JSON. Prenons un exemple classique avec des données utilisateur.

Déclaration de la structure

Ajoutons les annotations #[derive(Serialize, Deserialize)] à notre structure :

#[derive(Debug, Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n    is_active: bool,\n    tags: Vec<String>,\n}

Création d'une instance et sérialisation

Créons maintenant un objet et convertissons-le en JSON :

fn main() -> Result<()> {\n    let user = User {\n        id: 42,\n        name: "Alexeï".to_string(),\n        email: "alex@example.com".to_string(),\n        is_active: true,\n        tags: vec!["rust".to_string(), "backend".to_string()],\n    };\n\n    // Sérialisation en chaîne JSON\n    let json_string = serde_json::to_string(&user)?;\n    println!("{}", json_string);\n\n    // Sérialisation jolie (pretty)\n    let pretty_json = serde_json::to_string_pretty(&user)?;\n    println!("{}", pretty_json);\n\n    Ok(())\n}

Résultat de l'exécution :

{"id":42,"name":"Alexeï","email":"alex@example.com","is_active":true,"tags":["rust","backend"]}\n\n{\n  "id": 42,\n  "name": "Alexeï",\n  "email": "alex@example.com",\n  "is_active": true,\n  "tags": [\n    "rust",\n    "backend"\n  ]\n}

Remarquez : to_string_pretty ajoute des indentations et des sauts de ligne — idéal pour les fichiers de configuration ou les logs.

3. Parsing (désérialisation) : de JSON vers une structure Rust

La désérialisation est le processus inverse : nous recevons une chaîne JSON et la transformons en une structure Rust typée.

Parsing à partir d'une chaîne

fn parse_user_from_json(json_str: &str) -> Result<User> {\n    let user: User = serde_json::from_str(json_str)?;\n    Ok(user)\n}\n\nfn main() -> Result<()> {\n    let data = r#"\n        {\n            "id": 101,\n            "name": "Maria",\n            "email": "maria@example.com",\n            "is_active": false,\n            "tags": ["python", "data-science"]\n        }\n    "#;\n\n    let user = parse_user_from_json(data)?;\n    println!("Utilisateur : {:?}", user);\n    println!("Nom : {}", user.name);\n    println!("Actif : {}", user.is_active);\n\n    Ok(())\n}

Si le JSON ne correspond pas à la structure (par ex