Learn Rust Coding · Lezione

Uso del JSON

serde_json

Lezione 2 di 413 passaggi

Uso del JSON è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 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.

La crate serde_json

serde_json è l'implementazione del formato JSON per serde. Fornisce funzioni per convertire i valori Rust in testo JSON e viceversa.

to_string / from_str per il testo
Value per il JSON dinamico

Da struct a stringa JSON

serde_json::to_string serializza qualsiasi valore Serialize in una stringa JSON.

use serde::Serialize;

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

fn main() {
    let u = User { id: 1, name: "Alice".to_string() };
    let json = serde_json::to_string(&u).unwrap();
    println!("{}", json);
}

Da stringa JSON a struct

serde_json::from_str analizza il JSON e lo converte in un valore tipizzato, restituendo un Result per consentire di gestire input non validi.

use serde::Deserialize;

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

fn main() {
    let data = r#"{"id":1,"name":"Alice"}"#;
    let u: User = serde_json::from_str(data).unwrap();
    println!("{:?}", u);
}

Formattazione leggibile

Utilizzate to_string_pretty per ottenere JSON indentato e leggibile, utile per i file di configurazione e il debugging.

use serde::Serialize;

#[derive(Serialize)]
struct Cfg { debug: bool, level: u8 }

fn main() {
    let c = Cfg { debug: true, level: 3 };
    println!("{}", serde_json::to_string_pretty(&c).unwrap());
}

La macro json!

Costruite JSON direttamente nel codice con la macro json!, che produce un Value senza dover definire una struct.

use serde_json::json;

fn main() {
    let v = json!({
        "name": "Alice",
        "roles": ["admin", "user"]
    });
    println!("{}", v);
}

Il tipo Value

serde_json::Value è un enum che rappresenta qualsiasi nodo JSON: null, booleano, numero, stringa, array o oggetto. Utilizzatelo quando la struttura non è nota.

use serde_json::Value;

fn main() {
    let data = r#"{"name":"Bob","age":30}"#;
    let v: Value = serde_json::from_str(data).unwrap();
    println!("{}", v["name"]);
    println!("{}", v["age"]);
}

Lettura sicura da Value

L'accesso tramite indice restituisce un Value; utilizzate metodi di accesso come as_str o as_i64, che restituiscono Option, per leggere in modo sicuro i dati tipizzati.

use serde_json::Value;

fn name_of(v: &Value) -> Option<&str> {
    v.get("name")?.as_str()
}

Modellare l'accesso al JSON in Rust puro

La lettura di un valore tramite chiave, con un valore alternativo quando la chiave è assente, rispecchia il modo in cui si interroga un oggetto Value. Ecco lo stesso approccio con una HashMap.

use std::collections::HashMap;

fn main() {
    let mut obj: HashMap<&str, &str> = HashMap::new();
    obj.insert("name", "Alice");
    let name = obj.get("name").copied().unwrap_or("unknown");
    let city = obj.get("city").copied().unwrap_or("unknown");
    println!("name={} city={}", name, city);
}

Byte e writer

Per ottenere migliori prestazioni, to_vec serializza in byte, mentre to_writer trasmette direttamente a qualsiasi io::Write, ad esempio un file o un socket.

use serde::Serialize;

#[derive(Serialize)]
struct Msg { text: String }

fn to_bytes(m: &Msg) -> Vec<u8> {
    serde_json::to_vec(m).unwrap()
}

Gestione degli errori di analisi

from_str restituisce un Result. Gestite l'errore con un match per mostrare agli utenti un messaggio utile invece di causare un panic.

use serde::Deserialize;

#[derive(Deserialize)]
struct User { id: u32 }

fn parse(s: &str) -> String {
    match serde_json::from_str::<User>(s) {
        Ok(u) => format!("id {}", u.id),
        Err(e) => format!("invalid JSON: {}", e),
    }
}

Conversione tra Value e struct

serde_json::from_value e to_value convertono una struct tipizzata in un Value dinamico e viceversa, quando servono entrambi.

use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize)]
struct User { name: String }

fn main() {
    let v = json!({"name": "Eve"});
    let u: User = serde_json::from_value(v).unwrap();
    println!("{}", u.name);
}

Verifica rapida

Verificate la vostra comprensione dell'utilizzo del JSON.

Rispondi nella lezione interattiva

Riepilogo

Avete imparato a gestire il JSON con serde_json:

to_string / from_str convertono le struct in testo JSON e viceversa
to_string_pretty formatta il JSON in modo leggibile
La macro json! e Value gestiscono il JSON dinamico
Utilizzate i metodi di accesso e Result per leggere e analizzare i dati in sicurezza

Avanti: personalizzare la serializzazione con gli attributi dei campi.

Gratis per iniziare

Impara Rust con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 144

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Uso del JSON» è gratuita?

Sì — il testo completo di «Uso del JSON» è 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 «Uso del JSON»?

serde_json 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 2 di 4.

Quanto tempo richiede la lezione «Uso del JSON»?

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

← Torna a Learn Rust Coding