Learn Rust Coding · Leçon

Sérialiser et désérialiser

Macros de dérivation

Sérialiser et désérialiser est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What is Serde?

Serde (SERialize/DEserialize) is Rust's framework for converting data structures to and from formats like JSON, YAML, and more.

Format-agnostic core plus format crates
Driven by derive macros

Adding serde

Add serde with the derive feature, plus a format crate like serde_json. This edits Cargo.toml.

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

Deriving the traits

Annotate a struct with #[derive(Serialize, Deserialize)] to make it convertible. Each field must itself be serializable.

use serde::{Serialize, Deserialize};

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

Serialize means to a format

Serialize turns a value into bytes/text in some format. The struct does not know which format; the format crate decides.

Deserialize means from a format

Deserialize parses text/bytes back into a Rust value, validating types and required fields along the way.

Modeling serialize manually

To build intuition, here is a hand-written serializer for a simple struct. serde generates code like this for you.

struct User { id: u32, name: String }

fn serialize(u: &User) -> String {
    format!("id={};name={}", u.id, u.name)
}

fn main() {
    let u = User { id: 7, name: "Alice".to_string() };
    println!("{}", serialize(&u));
}

Modeling deserialize manually

And here is the reverse: parsing text back into the struct. serde's generated code does this robustly across formats.

struct User { id: u32, name: String }

fn deserialize(s: &str) -> User {
    let parts: Vec<&str> = s.split(',').collect();
    let id = parts[0].parse().unwrap();
    let name = parts[1].to_string();
    User { id, name }
}

fn main() {
    let u = deserialize("42,Bob");
    println!("{} {}", u.id, u.name);
}

Deriving on enums

Enums work too. By default each variant serializes by its name, with any data nested inside.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { radius: f64 },
    Square { side: f64 },
}

Nested structures

serde recurses automatically. A struct containing other derived structs or Vecs just works.

use serde::{Serialize, Deserialize};

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

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    addresses: Vec<Address>,
}

Serialize-only or Deserialize-only

You can derive just one trait. An API response type might be Serialize only; an incoming request type Deserialize only.

use serde::Serialize;

#[derive(Serialize)]
struct ApiResponse {
    status: u16,
    message: String,
}

Derive requirements

Every field type must implement the trait you derive. Standard types and collections already do; custom types need their own derive.

use serde::Serialize;

#[derive(Serialize)]
struct Inner { x: i32 }

#[derive(Serialize)]
struct Outer { inner: Inner }

Quick Check

Test your understanding of serialize and deserialize.

Recap

You learned the serde basics:

serde is a format-agnostic (de)serialization framework
#[derive(Serialize, Deserialize)] generates the conversion code
Works on structs, enums, and nested types
You can derive just one direction when appropriate

Next: working with JSON via serde_json.

Questions Fréquemment Posées

La leçon « Sérialiser et désérialiser » est-elle gratuite ?

Oui — le texte complet de « Sérialiser et désérialiser » 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érialiser et désérialiser » ?

Macros de dérivation 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 1 sur 4.

Combien de temps prend la leçon « Sérialiser et désérialiser » ?

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