Autres formats
TOML, YAML, bincode
Autres formats est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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.
Au-delà de JSON
Le cœur de serde est indépendant du format : la même structure dérivée fonctionne donc avec de nombreux formats, en changeant simplement la caisse du format.
- TOML pour la configuration
- YAML pour les données faciles à lire
- bincode pour le binaire compact
Une structure, plusieurs formats
Vous définissez la structure une seule fois. Chaque caisse de format fournit ses propres équivalents de to_string / from_str sur les mêmes implémentations Serialize / Deserialize.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Config {
name: String,
port: u16,
}TOML
TOML est très utilisé pour la configuration (Cargo.toml l’utilise lui-même). La caisse toml le sérialise et l’analyse.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_toml(c: &Config) -> String {
toml::to_string(c).unwrap()
}Analyser du TOML
Relisez une configuration TOML dans votre structure avec toml::from_str.
use serde::Deserialize;
#[derive(Deserialize)]
struct Config { name: String, port: u16 }
fn parse(s: &str) -> Config {
toml::from_str(s).unwrap()
}YAML
YAML convient aux données modifiées par des personnes et comportant des imbrications. Utilisez une caisse telle que serde_yaml, avec une interface de même forme.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_yaml(c: &Config) -> String {
serde_yaml::to_string(c).unwrap()
}bincode
bincode est un format binaire compact, idéal pour la mise en cache ou l’envoi sur le réseau lorsque la taille et la vitesse sont importantes et que les personnes ne le liront jamais.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_bytes(c: &Config) -> Vec<u8> {
bincode::serialize(c).unwrap()
}Choisir un format
Faites votre choix selon le public :
- Configuration lisible comportant des imbrications : TOML ou YAML
- Interfaces web : JSON
- Stockage ou transport binaire interne : bincode
Modéliser le choix du format
La décision consiste simplement à associer un cas d’utilisation à un format. Cet exemple exécutable reproduit cette logique de sélection.
fn pick_format(use_case: &str) -> &str {
match use_case {
"config" => "TOML",
"api" => "JSON",
"cache" => "bincode",
_ => "JSON",
}
}
fn main() {
println!("{}", pick_format("config"));
println!("{}", pick_format("cache"));
println!("{}", pick_format("api"));
}Faire un aller-retour avec des octets
Les formats binaires permettent un aller-retour : sérialisez en octets, puis désérialisez à nouveau dans la même structure. Cet exemple exécutable modélise conceptuellement un aller-retour fondé sur la longueur des octets.
fn encode(name: &str) -> Vec<u8> {
name.as_bytes().to_vec()
}
fn decode(bytes: &[u8]) -> String {
String::from_utf8(bytes.to_vec()).unwrap()
}
fn main() {
let bytes = encode("Alice");
println!("len={}", bytes.len());
println!("back={}", decode(&bytes));
}Particularités propres aux formats
Les formats n’offrent pas tous les mêmes possibilités. TOML interdit null et nécessite des tables pour les imbrications YAML prend en charge les ancres bincode ne se décrit pas lui-même, les deux côtés doivent donc partager le type.
Les attributs s’appliquent toujours
Les attributs #[serde(...)] que vous avez appris (rename, default, skip) fonctionnent avec tous les formats, car ils agissent au niveau de serde et non au niveau du format.
use serde::Serialize;
#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Config { max_connections: u32 }Vérification rapide
Vérifiez votre compréhension des autres formats.
Récapitulatif
Vous avez découvert d’autres formats de serde :
- Une même structure dérivée fonctionne avec TOML, YAML, JSON et bincode
- Chaque caisse de format propose des interfaces familières de style
to_string/from_str - Choisissez selon le public : configuration, interface de programmation ou stockage binaire
- Les attributs de serde s’appliquent à tous les formats
Le cours sur Serde et la série Rust sont maintenant terminés.
Questions Fréquemment Posées
La leçon « Autres formats » est-elle gratuite ?
Oui — le texte complet de « Autres formats » 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 « Autres formats » ?
TOML, YAML, bincode 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 4 sur 4.
Combien de temps prend la leçon « Autres formats » ?
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.