Travailler avec JSON en Rust : analyse, sérialisation et exemples pratiques

Introduction au JSON en Rust

JSON (JavaScript Object Notation) reste l'un des formats d'échange de données les plus populaires dans le développement web, les fichiers de configuration et les API. Le langage Rust, connu pour ses performances et sa sécurité mémoire, fournit des outils puissants pour travailler avec JSON via la crate serde_json. Dans cet article, nous allons examiner en détail comment effectuer l'analyse et la sérialisation JSON en Rust en utilisant des approches modernes et les meilleures pratiques.

La bibliothèque serde (framework de sérialisation/désérialisation) est la norme de facto pour travailler avec les formats de données dans l'écosystème Rust. Combinée à serde_json, elle permet de convertir facilement les structures Rust en JSON et vice versa.

Configuration du projet et installation des dépendances

Pour commencer, créez un nouveau projet Cargo et ajoutez les dépendances nécessaires au fichier Cargo.toml :

[dependencies]serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"

Le drapeau features = ["derive"] pour la crate serde active les macros #[derive(Serialize, Deserialize)], qui génèrent automatiquement le code de sérialisation et de désérialisation des structures.

Bases de l'analyse JSON en Rust

Analyse d'une chaîne JSON en une valeur dynamique

La façon la plus simple d'analyser du JSON est d'utiliser le type serde_json::Value, qui représente une valeur JSON générique :

use serde_json::Value;

fn main() {    let data = r#"    {        "name": "Alexey",        "age": 30,        "is_student": false,        "hobbies": ["reading", "programming", "cycling"]    }"#;

    let parsed: Value = serde_json::from_str(data).expect("Erreur d'analyse JSON");        println!("Nom : {}", parsed["name"]);    println!("Âge : {}", parsed["age"]);    println!("Étudiant : {}", parsed["is_student"]);    println!("Premier loisir : {}", parsed["hobbies"][0]);}

Le type Value est une énumération qui peut contenir Null, Bool, Number, String, Array ou Object. C'est pratique pour le prototypage rapide, mais pour le code de production, il est préférable d'utiliser des structures fortement typées.

Analyse JSON en structures fortement typées

Pour une manipulation sécurisée des données, définissez une structure qui correspond au schéma JSON et utilisez les macros serde :

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u32,    is_student: bool,    hobbies: Vec<String>,}

fn main() {    let json_str = r#"    {        "name": "Maria",        "age": 25,        "is_student": true,        "hobbies": ["drawing", "music"]    }"#;

    let person: Person = serde_json::from_str(json_str)        .expect("Erreur de désérialisation");        println!("{:?}", person);    println!("{} étudie : {}", person.name, person.is_student);}

L'avantage de cette approche est que le compilateur vérifie les types au moment de la compilation, éliminant ainsi les erreurs d'exécution liées à un accès incorrect aux champs.

Sérialisation des données en JSON

Conversion des structures en une chaîne JSON

La sérialisation s'effectue à l'aide de la fonction serde_json::to_string() :

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Product {    id: u64,    name: String,    price: f64,    in_stock: bool,}

fn main() {    let product = Product {        id: 42,        name: "Laptop".to_string(),        price: 89999.99,        in_stock: true,    };

    let json_string = serde_json::to_string(&product)        .expect("Erreur de sérialisation");        println!("JSON : {}", json_string);        // Impression formatée