Learn Rust Coding · Leçon

Sérialisation personnalisée

Attributs de champs

Sérialisation personnalisée est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.

Personnaliser serde

serde offre un contrôle précis sur la manière dont les champs correspondent à un format grâce aux attributs. Vous pouvez renommer les champs, les ignorer, définir des valeurs par défaut et bien plus encore, le tout avec #[serde(...)].

Renommer un champ

Utilisez rename pour associer le nom d’un champ Rust à une autre clé dans la sortie, ce qui est utile lorsque JSON utilise une convention différente.

use serde::Serialize;

#[derive(Serialize)]
struct User {
    #[serde(rename = "userName")]
    user_name: String,
}

Tout renommer

Appliquez une convention de nommage à tous les champs en une seule fois avec rename_all, par exemple de snake_case en Rust vers camelCase en JSON.

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct User {
    first_name: String,
    last_name: String,
}

Ignorer des champs

skip exclut complètement un champ. skip_serializing_if l’exclut sous certaines conditions, par exemple pour masquer les options vides.

use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    nickname: Option<String>,
}

Valeurs par défaut lors de la désérialisation

default fournit une valeur lorsqu’un champ est absent de l’entrée, afin que la désérialisation n’échoue pas.

use serde::Deserialize;

#[derive(Deserialize)]
struct Config {
    #[serde(default)]
    retries: u32,
}

Fonction par défaut personnalisée

Faites pointer default vers une fonction qui fournit une valeur de remplacement non nulle.

use serde::Deserialize;

fn default_port() -> u16 { 8080 }

#[derive(Deserialize)]
struct Config {
    #[serde(default = "default_port")]
    port: u16,
}

Modéliser rename + default

La logique des attributs se résume à associer des clés et à prévoir une valeur de remplacement. Cet exemple exécutable reproduit ce comportement avec un HashMap.

use std::collections::HashMap;

fn main() {
    let mut input: HashMap<&str, &str> = HashMap::new();
    input.insert("userName", "Alice");
    let user_name = input.get("userName").copied().unwrap_or("anon");
    let port = input.get("port").copied().unwrap_or("8080");
    println!("user_name={} port={}", user_name, port);
}

Alias lors de la désérialisation

alias accepte une autre clé lors de la lecture, ce qui est utile pour prendre en charge les anciens et les nouveaux noms de champs.

use serde::Deserialize;

#[derive(Deserialize)]
struct User {
    #[serde(alias = "username")]
    name: String,
}

Aplatir

flatten intègre les champs d’une structure imbriquée dans l’objet parent, supprimant ainsi un niveau d’imbrication dans le JSON.

use serde::Serialize;

#[derive(Serialize)]
struct Meta { page: u32 }

#[derive(Serialize)]
struct Resp {
    data: String,
    #[serde(flatten)]
    meta: Meta,
}

Personnalisation avec un module

Pour un contrôle total, faites pointer with vers un module qui expose des fonctions serialize et deserialize, par exemple pour formater un horodatage.

use serde::Serialize;

#[derive(Serialize)]
struct Event {
    #[serde(with = "my_date_format")]
    at: i64,
}

Étiquetage des énumérations

Contrôlez la façon dont les énumérations sont encodées avec tag (étiquetage interne) ou untagged. Cela définit la forme du JSON pour les types à variantes.

use serde::Serialize;

#[derive(Serialize)]
#[serde(tag = "type")]
enum Event {
    Click { x: i32, y: i32 },
    Key { code: u8 },
}

Vérification rapide

Vérifiez votre compréhension de la sérialisation personnalisée.

Récapitulatif

Vous avez appris à personnaliser la sérialisation :

rename et rename_all associent les noms de champs
skip et skip_serializing_if contrôlent la sortie
default et alias facilitent la désérialisation
flatten, with et tag pour les énumérations gèrent la structure

Ensuite : les formats autres que JSON.

Questions Fréquemment Posées

La leçon « Sérialisation personnalisée » est-elle gratuite ?

Oui — le texte complet de « Sérialisation personnalisée » 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 « Sérialisation personnalisée » ?

Attributs de champs 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 3 sur 4.

Combien de temps prend la leçon « Sérialisation personnalisée » ?

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