Altri formati
TOML, YAML, bincode
Altri formati è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Oltre il JSON
Il nucleo di serde è indipendente dal formato, quindi la stessa struct derivata funziona con molti formati semplicemente sostituendo il crate del formato.
- TOML per la configurazione
- YAML per dati facili da leggere per gli esseri umani
- bincode per dati binari compatti
Una struct, molti formati
Definite la struct una sola volta. Ogni crate del formato fornisce i propri equivalenti di to_string / from_str, utilizzando le stesse implementazioni di Serialize / Deserialize.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Config {
name: String,
port: u16,
}TOML
TOML è molto utilizzato per la configurazione (lo stesso Cargo.toml usa questo formato). Il crate toml lo serializza e lo analizza.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_toml(c: &Config) -> String {
toml::to_string(c).unwrap()
}Analizzare TOML
Leggete nuovamente una configurazione TOML nella vostra struct con 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 è adatto ai dati modificati dagli esseri umani e dotati di struttura annidata. Utilizzate un crate come serde_yaml, con la stessa struttura dell'API.
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 è un formato binario compatto, ideale per il caching o l'invio tramite rete quando dimensioni e velocità sono importanti e i dati non devono essere letti dagli esseri umani.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_bytes(c: &Config) -> Vec<u8> {
bincode::serialize(c).unwrap()
}Scegliere un formato
Scegliete in base ai destinatari:
- Configurazioni leggibili con struttura annidata: TOML o YAML
- API web: JSON
- Archiviazione o trasporto binario interno: bincode
Modellare la scelta del formato
La decisione consiste semplicemente nell'associare il caso d'uso al formato. Questo esempio eseguibile riproduce la logica di selezione.
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"));
}Round-trip dei byte
I formati binari consentono un round-trip: serializzate in byte e poi deserializzate nuovamente nella stessa struct. Questo esempio eseguibile modella concettualmente un round-trip basato sulla lunghezza dei byte.
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));
}Specificità dei formati
I formati differiscono per funzionalità. TOML non consente i valori null e richiede tabelle per la struttura annidata; YAML supporta gli anchor; bincode non è auto-descrittivo, quindi entrambe le parti devono condividere il tipo.
Gli attributi continuano a valere
Gli attributi #[serde(...)] che avete imparato (rename, default, skip) funzionano con tutti i formati, perché operano a livello di serde, non a livello di formato.
use serde::Serialize;
#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Config { max_connections: u32 }Verifica rapida
Verificate la vostra comprensione degli altri formati.
Riepilogo
Avete imparato a conoscere altri formati supportati da serde:
- Una struct derivata funziona con TOML, YAML, JSON e bincode
- Ogni crate del formato offre API familiari nello stile di
to_string/from_str - Scegliete in base ai destinatari: configurazione, API o archiviazione binaria
- Gli attributi di serde si applicano a ogni formato
Con questo si conclude il corso su Serde e la serie su Rust.
Domande Frequenti
La lezione «Altri formati» è gratuita?
Sì — il testo completo di «Altri formati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Altri formati»?
TOML, YAML, bincode Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Altri formati»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.