JSON en Rust pour débutants : analyse et sérialisation de données

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction au travail avec JSON en Rust

JSON (JavaScript Object Notation) est l'un des formats d'échange de données les plus populaires dans le développement web, les fichiers de configuration et les API. Si vous apprenez Rust et souhaitez apprendre à travailler efficacement avec JSON, cet article est pour vous. Nous examinerons les bibliothèques principales, les principes d'analyse et de sérialisation, et analyserons des exemples de code pratiques.

Dans l'écosystème Rust, le travail avec JSON est construit autour de la crate serde — un puissant framework de sérialisation et désérialisation de données. Associé à serde_json, il permet de transformer facilement des structures de données en JSON et vice versa. Voyons comment cela fonctionne.

Installation et configuration des dépendances

Pour commencer, créons un nouveau projet et ajoutons les dépendances nécessaires dans le fichier Cargo.toml :

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

La crate serde fournit les macros #[derive(Serialize, Deserialize)], qui implémentent automatiquement les traits nécessaires pour vos structures. serde_json est responsable directement du travail avec le format JSON.

Analyse JSON : de la chaîne à la structure

Supposons que nous ayons une chaîne JSON contenant des informations sur un utilisateur. Nous voulons la transformer en une structure Rust typée. Voici comment faire :

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]struct User {    name: String,    age: u32,    email: String,    is_active: bool,}

fn main() {    let json_data = r#"        {            "name": "Alexeï",            "age": 28,            "email": "alex@example.com",            "is_active": true        }    "#;

    // Analyse JSON en structure    let user: User = serde_json::from_str(json_data).expect("Erreur d'analyse JSON");        println!("Utilisateur : {:?}", user);    println!("Nom : {}", user.name);    println!("Âge : {}", user.age);}

Notez l'attribut #[derive(Debug, Deserialize, Serialize)]. Debug permet d'afficher la structure dans la console, tandis que Deserialize et Serialize permettent de transformer les données en JSON et vice versa.

Traitement des objets imbriqués

JSON contient souvent des objets imbriqués. Prenons un exemple avec une adresse utilisateur :

#[derive(Debug, Deserialize, Serialize)]struct Address {    city: String,    street: String,    zip_code: String,}

#[derive(Debug, Deserialize, Serialize)]struct User {    name: String,    age: u32,    address: Address,}

fn main() {    let json_data = r#"        {            "name": "Maria",            "age": 32,            "address": {                "city": "Moscou",                "street": "Tverskaïa, 15",                "zip_code": "101000"            }        }    "#;

    let user: User = serde_json::from_str(json_data).unwrap();    println!("Ville : {}", user.address.city);}

Travail avec les tableaux JSON

Les tableaux en JSON sont transformés en Vec ou autres collections Rust :

use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Product {    id: u32,    name: String,    price: f64,}

fn main() {    let json_array = r#"        [            {"id": 1, "name": "Ordinateur portable", "price": 75000.50},            {"id": 2, "name": "Souris", "price": 1500.00},            {"id": 3, "name": "Clavier", "price": 3500.00}        ]    "#;

    let products: Vec<Product> = serde_json::from_str(json_array).unwrap();        for product in &products {        println!("{} : {} roubles", product.name, product.price);    }}