Serializzazione e deserializzazione JSON con Rust

JSON (JavaScript Object Notation) è emerso come un popolare formato di interscambio di dati nel software sviluppo grazie alla sua semplicità, leggibilità e supporto diffuso in vari programmi le lingue. JSON è un'alternativa leggera a XML per la trasmissione di dati tra un server e un'applicazione Web o tra diversi componenti del sistema software.

Uno degli aspetti chiave del lavoro con JSON è il processo di serializzazione e deserializzazione che ti consente di convertire i dati JSON in un formato strutturato che puoi facilmente manipolare all'interno del tuo programmi. La maggior parte delle volte, se si desidera lavorare con JSON in altri linguaggi, potrebbe essere necessario serializzare e deserializzare i dati JSON nelle strutture di dati integrate del linguaggio.

Iniziare con Serde

Serde (serializzazione e deserializzazione) è una libreria Rust ampiamente utilizzata che fornisce un framework per la conversione

Strutture dati ruggine in formati per l'archiviazione, la trasmissione, la condivisione e altri.

Serde consente la conversione senza soluzione di continuità tra i tipi di dati Rust e vari formati di interscambio di dati, inclusi JSON, YAML, BSON, CBOR, MessagePack e altri.

L'obiettivo principale di Serde è rendere il processo di serializzazione e deserializzazione il più semplice ed efficiente possibile, pur mantenendo solide caratteristiche di tipizzazione e sicurezza.

Aggiungi queste direttive al file dipendenze sezione del tuo Cargo.toml file da installare e utilizzare Serde come un dipendenza di terzi con Cargo.

[dipendenze]
serde = { versione = "1.0.159", caratteristiche = ["derivare"] }
serde_json = "1.0.96"

Avrai bisogno di entrambi i serde E serde_json casse per interagire con JSON. IL serde crate fornisce le funzionalità principali e il serde_json crate è un'implementazione specifica di Serde per lavorare con JSON.

Ecco come puoi importare il file serde_json cassa e il Serializza E Deserializzare moduli dal serde cassa:

utilizzo serde::{Serializza, Deserializza};
utilizzo serde_json;

Nel complesso, Serde è uno strumento potente di cui avrai bisogno nel tuo arsenale di sviluppo se lavori con JSON in Rust.

Serializzazione dei dati con Serde

Il processo di serializzazione JSON comporta la conversione di un tipo Rust (personalizzato o integrato) in JSON per altre operazioni. Serde fornisce un set di attributi che puoi usare con Rust struct per abilitare un controllo preciso sul processo di serializzazione, incluso il file #[deriva (serializza)] attributo che ti consente di generare codice di serializzazione per le tue strutture dati e convertire la tua struttura Rust in JSON.

Considera questa struttura che rappresenta i dati anagrafici di una persona; ecco come puoi importare e utilizzare il file Serializza attributo sulla struttura:

utilizzo serde::{Serializza, Deserializza};
utilizzo serde_json;
#[deriva (serializza)]
structPersona {
 nome: Corda,
 età: u32,
}

Annotando il Persona struct con il [#derive (Serializza)], stai dicendo a Serde di generare il codice di serializzazione necessario per il file Persona struct automaticamente.

Ecco come è possibile serializzare un'istanza di Persona struct in JSON:

utilizzo serde::{Serializza};
utilizzo serde_json;
fnprincipale() {
// dichiarazione dell'istanza struct Person con i campi name ed age
permettere persona = Persona {
 nome: "Chukwuemeriwo".accordare(),
 età: 28,
 };
// serializza la struttura person in JSON utilizzando la libreria serde_json
permettere json = serde_json:: to_string(&person).expect("Serializzazione fallita");
// stampa la stringa JSON serializzata
stampa!("JSON serializzato: {}", json);
}

Nel principale funzione, il serde_json crate serializza il file persona oggetto. IL accordare la funzione accetta un riferimento a persona oggetto e restituisce una stringa JSON che rappresenta i dati serializzati.

Infine il principale la funzione stampa il JSON serializzato sulla console.

IL serde E serde_json sono versatili, puoi anche serializzare gli array con serde.

utilizzo serde::{Serializza, Deserializza};
utilizzo serde_json;
#[deriva (serializza)]
structCoordinate {
 X: f32,
 e: f32,
}
fnprincipale() {
permettere punti = vec![ 
 Coordinate {x: 1.0, io: 2.0 },
 Coordinate {x: 3.5, io: 4.5 },
 ];
permettere json = serde_json:: to_string(&punti).expect("Serializzazione fallita"); 
stampa!("JSON serializzato: {}", json); // Stampa la stringa JSON serializzata
}

IL punti la variabile è un vettore di Coordinate struct che rappresentano punti su un piano. Applicando il Serializza attribuire al Coordinate struct ti consente di serializzare il vettore in JSON senza sforzo.

Inoltre, puoi serializzare gli enum in JSON con serde come serializzare strutture e vettori.

utilizzo serde::{Serializza, Deserializza};
utilizzo serde_json;
#[derive (Serializza, Deserializza)]
enumAnimale {
 Cane(Corda),
 Gatto(u32),
 Uccello,
}
fnprincipale() {
permettere cane = Animale:: Cane("Arrugginito".accordare());
permettere json = serde_json:: to_string(&dog).expect("Serializzazione fallita");
stampa!("JSON serializzato: {}", json);
}

A seconda della variante, il processo di serializzazione si adatta di conseguenza (in questo caso, il file Animale:: Cane la variante include a Corda campo che Serde serializzerà come stringa JSON).

Deserializzazione dei dati con Serde

La deserializzazione JSON è il processo di trasformazione dei dati JSON in tipi di dati nativi di un linguaggio di programmazione. Serde fornisce un framework completo per la deserializzazione JSON che funziona sulla maggior parte dei tipi di dati incorporati.

Simile alla serializzazione, Serde offre attributi che puoi usare per annotare le tue strutture Rust per il processo di deserializzazione. Due attributi comunemente usati per la serializzazione sono i #[deriva (deserializza)] E #[serde (rename = "json_field_name")] attributi.

IL #[deriva (deserializza)] L'attributo deriva automaticamente l'implementazione della deserializzazione per il tuo Tipi di struttura ruggine, mentre il #[serde (rename = "json_field_name")] L'attributo consente di mappare i campi struct ai nomi dei campi JSON corrispondenti.

Ecco come puoi deserializzare i dati JSON in un tipo struct personalizzato con Serde:

utilizzo serde:: Deserializza;
utilizzo serde_json;
// definisce una struttura per Person con il tratto Deserialize da Serde
#[deriva (deserializza)]
structPersona {
#[serde (rinomina = "nome")]// rinomina il campo in "nome" 
 nome e cognome: Corda, 
 età: u32,
}
fnprincipale() {
permettere json_data = r#"
 {
"nome": "Giovanni Rossi",
"età": 30
 }
"#;
// deserializza i dati JSON in una struttura Person 
permettere persona: Persona = serde_json:: from_str (json_data).unwrap();
// Stampa il nome completo e l'età della persona
stampa!("Nome: {}", persona.nome_completo);
stampa!("Età: {}", persona.età);
}

Annotando il Persona struct con il #[deriva (deserializza)] attributo, indichi che Serde può deserializzare la struttura da JSON. IL #[serde (rinominare = "nome")] l'attributo mappa il nome campo nel JSON al file nome e cognome campo.

IL da_str funzione deserializza il json_data variabile nella persona oggetto, e il principale la funzione stampa i campi nella console.

Serde supporta la deserializzazione su vari tipi di dati Rust, inclusi tipi primitivi, enum, strutture annidate e raccolte.

Ecco come puoi deserializzare un array JSON in una struttura Rust contenente un campo vettoriale:

utilizzo serde:: Deserializza;
#[deriva (deserializza)]
structDati {
 numeri: Vec<u32>,
}
fnprincipale() {
permettere json_data = r#"
 {
"numeri": [1, 2, 3, 4, 5]
 }
"#;
permettere dati: Dati = serde_json:: from_str (json_data).unwrap();
per numero In dati.numeri {
stampa!("Numero: {}", numero);
 }
}

IL principale funzione deserializza il json_data contenuto JSON nel file dati variabile e il ciclo stampa gli elementi nel vettore.

È necessario assicurarsi di disporre dei tipi di dati e degli identificatori corretti per un processo di deserializzazione.

Serde interagisce con i popolari framework web di Rust

Serde è una potente libreria con molte funzionalità e una semplice API per serializzare e deserializzare i dati in diversi formati.

Serde è ampiamente adottato nell'ecosistema Rust e molti crate e framework popolari sono integrati supporto per Serde, inclusi framework Web popolari come Actix, Warp e Rocket e ORM di database come Diesel.