0Pricing
Learn Rust Coding · Lezione

Serializzazione e deserializzazione

Macro derive

Serializzazione e deserializzazione è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è Serde?

Serde (SERialize/DEserialize) è il framework di Rust per convertire le strutture dati da e verso formati come JSON, YAML e altri.

  • Un nucleo indipendente dal formato, affiancato da crate per i singoli formati
  • Basato sulle macro derive

Aggiungere serde

Aggiunga serde con la funzionalità derive, oltre a una crate per il formato, come serde_json. Questa operazione modifica Cargo.toml.

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

Derivare i trait

Annoti una struct con #[derive(Serialize, Deserialize)] per renderla convertibile. Ogni campo deve essere a sua volta serializzabile.

use serde::{Serialize, Deserialize};

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

Serialize significa verso un formato

Serialize trasforma un valore in byte o testo in un determinato formato. La struct non sa quale formato verrà usato: se ne occupa la crate del formato.

Deserialize significa da un formato

Deserialize analizza testo o byte e li riconverte in un valore Rust, verificando nel frattempo i tipi e i campi obbligatori.

Rappresentare manualmente la serializzazione

Per sviluppare l'intuizione, ecco un serializer scritto manualmente per una struct semplice. serde genera per Lei un codice simile.

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));
}

Rappresentare manualmente la deserializzazione

Ed ecco l'operazione inversa: analizzare il testo per riconvertirlo nella struct. Il codice generato da serde esegue questa operazione in modo affidabile tra diversi formati.

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);
}

Derivare i trait sugli enum

Funziona anche con gli enum. Per impostazione predefinita, ogni variante viene serializzata usando il proprio nome, con eventuali dati annidati al suo interno.

use serde::{Serialize, Deserialize};

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

Strutture annidate

serde gestisce automaticamente la ricorsione. Una struct che contiene altre struct derivate o Vec funziona senza configurazioni aggiuntive.

use serde::{Serialize, Deserialize};

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

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

Solo Serialize o solo Deserialize

Può derivare un solo trait. Un tipo per la risposta di un'API potrebbe implementare solo Serialize; un tipo per una richiesta in ingresso, solo Deserialize.

use serde::Serialize;

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

Requisiti per derive

Ogni tipo di campo deve implementare il trait derivato. I tipi e le collezioni standard lo implementano già; i tipi personalizzati richiedono il proprio derive.

use serde::Serialize;

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

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

Verifica rapida

Verifichi la sua comprensione della serializzazione e della deserializzazione.

Riepilogo

Ha appreso le basi di serde:

  • serde è un framework di (de)serializzazione indipendente dal formato
  • #[derive(Serialize, Deserialize)] genera il codice di conversione
  • Funziona con struct, enum e tipi annidati
  • Quando opportuno, può derivare una sola direzione

Prossimo argomento: lavorare con JSON tramite serde_json.

Domande Frequenti

La lezione «Serializzazione e deserializzazione» è gratuita?

Sì — il testo completo di «Serializzazione e deserializzazione» è 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 «Serializzazione e deserializzazione»?

Macro derive 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 1 di 4.

Quanto tempo richiede la lezione «Serializzazione e deserializzazione»?

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.

Tutte le lezioni di questo corso

  1. Serializzazione e deserializzazione
  2. Uso del JSON
  3. Serializzazione personalizzata
  4. Altri formati
← Torna a Learn Rust Coding