Traitement JSON en Rust : bibliothèques serde_json et json

Traitement JSON en Rust : serde_json et travail avec les données

JSON (JavaScript Object Notation) reste l'un des formats d'échange de données les plus populaires dans le développement web, les API et les fichiers de configuration. Dans le langage Rust, réputé pour ses performances et sa sécurité, le travail avec JSON est implémenté via un puissant écosystème de crates. L'outil principal est la bibliothèque serde_json, construite sur le framework de sérialisation serde. Dans cet article, nous allons détailler comment analyser, créer et transformer du JSON en Rust, ainsi qu'examiner des approches alternatives.

1. Installation et intégration de serde_json

Pour commencer, ajoutez les dépendances dans le fichier Cargo.toml :

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

serde fournit les traits Serialize et Deserialize, tandis que serde_json en est l'implémentation concrète pour JSON. Après avoir ajouté les crates, vous pouvez les importer dans le code :

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

2. Sérialisation de structures en JSON

Pour transformer une structure Rust en JSON, il faut l'annoter avec les attributs #[derive(Serialize)]. Prenons un exemple avec des données utilisateur :

#[derive(Serialize)]struct User {    name: String,    age: u8,    email: String,    active: bool,}

fn main() -> Result<()> {    let user = User {        name: "Алексей".to_string(),        age: 30,        email: "alex@example.com".to_string(),        active: true,    };

    let json = serde_json::to_string(&user)?;    println!("{}", json);    // Sortie : {"name":"Алексей","age":30,"email":"alex@example.com","active":true}    Ok(())}

La méthode serde_json::to_string retourne un Result<String>. Pour une sortie formatée, utilisez serde_json::to_string_pretty.

3. Désérialisation de JSON en structures

Le processus inverse — transformation d'une chaîne JSON en structure Rust. Pour cela, la structure doit implémenter Deserialize :

#[derive(Deserialize, Debug)]struct User {    name: String,    age: u8,    email: String,    active: bool,}

fn main() -> Result<()> {    let data = r#"        {            "name": "Мария",            "age": 25,            "email": "maria@example.com",            "active": false        }"#;

    let user: User = serde_json::from_str(data)?;    println!("{:?}", user);    // Sortie : User { name: "Мария", age: 25, email: "maria@example.com", active: false }    Ok(())}

Si le JSON contient des champs absents de la structure, ou inversement, utilisez les attributs #[serde(default)] ou #[serde(skip_serializing_if = "Option::is_none")].

4. Travail avec du JSON arbitraire (Value)

Parfois, la structure des données n'est pas connue à l'avance. Dans ce cas, on utilise l'énumération serde_json::Value, qui peut représenter n'importe quel type JSON :

use serde_json::Value;

fn main() -> Result<()> {    let data = r#"        {            "name": "Иван",            "age": 35,            "hobbies": ["чтение", "программирование"],            "address": null        }"#;

    let v: Value = serde_json::from_str(data)?;

    // Accès aux champs    if let Some(name) = v.get("name") {        println!("Nom : {}", name);    }

    // Extraction d'un tableau    if let Some(hobbies) = v.get("hobbies").and_then(|h| h.as_array()) {        for hobby in hobbies {            println!("Loisir : {}", hobby);        }    }

    Ok(())}

Value prend en charge les méthodes as_str(), as_u64(), as_array() et d'autres pour une extraction sécurisée des données.