Learn Rust Coding · Leçon

Manipulation de JSON

serde_json

Leçon 2 sur 413 étapes

Manipulation de JSON est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

La caisse serde_json

serde_json est l’implémentation du format JSON pour serde. Elle fournit des fonctions permettant de convertir des valeurs Rust en texte JSON et inversement.

to_string / from_str pour le texte
Value pour le JSON dynamique

Convertir une structure en chaîne JSON

serde_json::to_string sérialise toute valeur Serialize en chaîne JSON.

use serde::Serialize;

#[derive(Serialize)]
struct User { id: u32, name: String }

fn main() {
    let u = User { id: 1, name: "Alice".to_string() };
    let json = serde_json::to_string(&u).unwrap();
    println!("{}", json);
}

Convertir une chaîne JSON en structure

serde_json::from_str analyse le JSON pour produire une valeur typée et renvoie un Result afin que vous puissiez gérer les données d’entrée malformées.

use serde::Deserialize;

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

fn main() {
    let data = r#"{"id":1,"name":"Alice"}"#;
    let u: User = serde_json::from_str(data).unwrap();
    println!("{:?}", u);
}

Mise en forme lisible

Utilisez to_string_pretty pour obtenir un JSON indenté et lisible, pratique pour les fichiers de configuration et le débogage.

use serde::Serialize;

#[derive(Serialize)]
struct Cfg { debug: bool, level: u8 }

fn main() {
    let c = Cfg { debug: true, level: 3 };
    println!("{}", serde_json::to_string_pretty(&c).unwrap());
}

La macro json!

Construisez du JSON directement avec la macro json!, qui produit une Value sans définir de structure.

use serde_json::json;

fn main() {
    let v = json!({
        "name": "Alice",
        "roles": ["admin", "user"]
    });
    println!("{}", v);
}

Le type Value

serde_json::Value est une énumération représentant n’importe quel nœud JSON : null, booléen, nombre, chaîne, tableau ou objet. Utilisez-le lorsque la forme est inconnue.

use serde_json::Value;

fn main() {
    let data = r#"{"name":"Bob","age":30}"#;
    let v: Value = serde_json::from_str(data).unwrap();
    println!("{}", v["name"]);
    println!("{}", v["age"]);
}

Lire une Value en toute sécurité

L’accès par index renvoie une Value ; utilisez des méthodes d’accès comme as_str ou as_i64, qui renvoient un Option, pour lire les données typées en toute sécurité.

use serde_json::Value;

fn name_of(v: &Value) -> Option<&str> {
    v.get("name")?.as_str()
}

Modéliser l’accès au JSON en Rust simple

Lire une valeur par clé, avec une valeur de remplacement lorsqu’elle est absente, reproduit la manière dont vous interrogez un objet Value. Voici le même principe avec un HashMap.

use std::collections::HashMap;

fn main() {
    let mut obj: HashMap<&str, &str> = HashMap::new();
    obj.insert("name", "Alice");
    let name = obj.get("name").copied().unwrap_or("unknown");
    let city = obj.get("city").copied().unwrap_or("unknown");
    println!("name={} city={}", name, city);
}

Octets et écrivains

Pour de meilleures performances, to_vec sérialise en octets et to_writer écrit directement dans n’importe quel io::Write, par exemple un fichier ou une socket.

use serde::Serialize;

#[derive(Serialize)]
struct Msg { text: String }

fn to_bytes(m: &Msg) -> Vec<u8> {
    serde_json::to_vec(m).unwrap()
}

Gérer les erreurs d’analyse

from_str renvoie un Result. Traitez l’erreur pour fournir un message utile aux utilisateurs au lieu de provoquer une panique.

use serde::Deserialize;

#[derive(Deserialize)]
struct User { id: u32 }

fn parse(s: &str) -> String {
    match serde_json::from_str::<User>(s) {
        Ok(u) => format!("id {}", u.id),
        Err(e) => format!("invalid JSON: {}", e),
    }
}

Convertir entre Value et structures

serde_json::from_value et to_value convertissent une structure typée et la Value dynamique dans les deux sens lorsque vous avez besoin des deux.

use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize)]
struct User { name: String }

fn main() {
    let v = json!({"name": "Eve"});
    let u: User = serde_json::from_value(v).unwrap();
    println!("{}", u.name);
}

Vérification rapide

Testez votre compréhension de l’utilisation de JSON.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris à manipuler JSON avec serde_json :

to_string / from_str convertissent les structures et le texte JSON
to_string_pretty produit une mise en forme lisible
La macro json! et Value gèrent le JSON dynamique
Utilisez les accesseurs et Result pour lire et analyser les données en toute sécurité

Ensuite : personnaliser la sérialisation avec les attributs de champ.

Gratuit pour commencer

Apprends Rust avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 39
Leçons: 144

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Manipulation de JSON » est-elle gratuite ?

Oui — le texte complet de « Manipulation de JSON » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Manipulation de JSON » ?

serde_json Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Manipulation de JSON » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding