JSON serialisering og deserialisering med rust

JSON (JavaScript Object Notation) har dukket opp som et populært datautvekslingsformat i programvare utvikling på grunn av sin enkelhet, lesbarhet og omfattende støtte på tvers av ulike programmeringer språk. JSON er et lettvektsalternativ til XML for overføring av data mellom en server og en webapplikasjon eller mellom ulike programvaresystemkomponenter.

En av nøkkelaspektene ved å jobbe med JSON er prosessen med serialisering og deserialisering som lar deg konvertere JSON-data til et strukturert format som du enkelt kan manipulere i din programmer. De fleste ganger, hvis du vil jobbe med JSON på andre språk, må du kanskje serialisere og deserialisere JSON-dataene til språkets innebygde datastrukturer.

Komme i gang med Serde

Serde (serialisering og deserialisering) er et mye brukt Rust-bibliotek som gir et rammeverk for konvertering Rustdatastrukturer til formater for lagring, overføring, deling og annet.

Serde muliggjør sømløs konvertering mellom Rust-datatyper og ulike datautvekslingsformater, inkludert JSON, YAML, BSON, CBOR, MessagePack og andre.

Serdes primære fokus er å gjøre serialiserings- og deserialiseringsprosessen så enkel og effektiv som mulig, samtidig som sterke skrive- og sikkerhetsfunksjoner opprettholdes.

Legg til disse direktivene til avhengigheter delen av din Cargo.toml fil å installere og bruke Serde som en tredjepartsavhengighet med Cargo.

[avhengigheter]
serde = { versjon = "1.0.159", funksjoner = ["avlede"] }
serde_json = "1.0.96"

Du trenger både serde og serde_json kasser for å samhandle med JSON. De serde kasse gir kjernefunksjonene, og serde_json crate er en spesifikk implementering av Serde for arbeid med JSON.

Slik kan du importere serde_json kasse og Serialiser og Deserialiser moduler fra serde kasse:

bruk serde::{Serialize, Deserialize};
bruk serde_json;

Samlet sett er Serde et kraftig verktøy du trenger i utviklingsarsenalet ditt hvis du jobber med JSON i Rust.

Dataserialisering med Serde

JSON-serialiseringsprosessen innebærer å konvertere en Rust-type (egendefinert eller innebygd) til JSON for andre operasjoner. Serde gir et sett med attributter du kan bruke med Rust struct for å muliggjøre presis kontroll over serialiseringsprosessen, inkludert #[derive (Serialize)] attributt som lar deg generere serialiseringskode for datastrukturene dine og konvertere Rust-strukturen til JSON.

Tenk på at denne strukturen representerer en persons biodata; her er hvordan du kan importere og bruke Serialiser attributt på strukturen:

bruk serde::{Serialize, Deserialize};
bruk serde_json;
#[derive (Serialize)]
strukturPerson {
 Navn: String,
 alder: u32,
}

Ved å kommentere Person struktur med [#derive (Serialize)], ber du Serde om å generere den nødvendige serialiseringskoden for Person strukturer automatisk.

Slik kan du serialisere en forekomst av Person struct til JSON:

bruk serde::{Serialize};
bruk serde_json;
fnhoved-() {
// erklæring om Person struct-forekomsten med navn og aldersfelt
la person = Person {
 Navn: "Chukwuemeriwo".to_string(),
 alder: 28,
 };
// serialiserer personstrukturen til JSON ved å bruke serde_json-biblioteket
la json = serde_json:: to_string(&person).expect("Serialisering mislyktes");
// skriver ut den serialiserte JSON-strengen
println!("Serialisert JSON: {}", json);
}

I hoved- funksjon, den serde_json kasse serialiserer person gjenstand. De til_streng funksjonen tar en referanse til person objekt og returnerer en JSON-streng som representerer de serialiserte dataene.

Til slutt, den hoved- funksjonen skriver ut den serialiserte JSON-en til konsollen.

De serde og serde_json er allsidige, kan du også serialisere arrays med serde.

bruk serde::{Serialize, Deserialize};
bruk serde_json;
#[derive (Serialize)]
strukturKoordinater {
 x: f32,
 y: f32,
}
fnhoved-() {
la poeng = vec![ 
 Koordinater { x: 1.0, y: 2.0 },
 Koordinater { x: 3.5, y: 4.5 },
 ];
la json = serde_json:: to_string(&points).expect("Serialisering mislyktes"); 
println!("Serialisert JSON: {}", json); // Skriv ut den serialiserte JSON-strengen
}

De poeng variabel er en vektor av Koordinater strukturer som representerer punkter på et plan. Bruk av Serialiser attributt til Koordinater struct lar deg serialisere vektoren til JSON uten problemer.

I tillegg kan du serialisere enums til JSON med serde som du serialiserer strukturer og vektorer.

bruk serde::{Serialize, Deserialize};
bruk serde_json;
#[avlede (Serialize, Deserialize)]
enumDyr {
 Hund(String),
 Katt(u32),
 Fugl,
}
fnhoved-() {
la hund = Dyr:: Hund("Rusten".to_string());
la json = serde_json:: to_string(&dog).expect("Serialisering mislyktes");
println!("Serialisert JSON: {}", json);
}

Avhengig av varianten tilpasser serialiseringsprosessen seg tilsvarende (i dette tilfellet Dyr:: Hund variant inkluderer en String feltet som Serde vil serialisere som en JSON-streng).

Dataserialisering med Serde

JSON-deserialisering er prosessen med å transformere JSON-data til innfødte datatyper for et programmeringsspråk. Serde gir et omfattende rammeverk for JSON-deserialisering som fungerer på de fleste innebygde datatyper.

I likhet med serialisering tilbyr Serde attributter som du kan bruke til å kommentere Rust-strukturene dine for deserialiseringsprosessen. To ofte brukte attributter for serialisering er #[derive (Deserialize)] og #[serde (rename = "json_field_name")] attributter.

De #[derive (Deserialize)] attributt utleder automatisk deserialiseringsimplementeringen for din Ruststrukturtyper, mens #[serde (rename = "json_field_name")] attributt lar deg tilordne struct-felt til tilsvarende JSON-feltnavn.

Slik kan du deserialisere JSON-data til en tilpasset strukturtype med Serde:

bruk serde:: Deserialize;
bruk serde_json;
// definerer en struktur for Person med Deserialize-trekket fra Serde
#[derive (Deserialize)]
strukturPerson {
#[serde (gi nytt navn = "Navn")]// endrer navn på feltet til "navn" 
 fullt navn: String, 
 alder: u32,
}
fnhoved-() {
la json_data = r#"
 {
"Navn": "John Doe",
"alder": 30
 }
"#;
// deserialiserer JSON-dataene til en personstruktur 
la person: Person = serde_json:: from_str (json_data).unwrap();
// Skriv ut fullt navn og alder på personen
println!("Navn: {}", person.full_name);
println!("Alder: {}", person.alder);
}

Ved å kommentere Person struktur med #[derive (Deserialize)] attributt, indikerer du at Serde kan deserialisere strukturen fra JSON. De #[serde (gi nytt navn = "navn")] attributt kartlegger Navn feltet i JSON til fullt navn felt.

De fra_str funksjonen deserialiserer json_data variabel inn i person objekt, og hoved- funksjonen skriver ut feltene til konsollen.

Serde støtter deserialisering på forskjellige Rust-datatyper, inkludert primitive typer, enums, nestede strukturer og samlinger.

Slik kan du deserialisere en JSON-matrise til en Rust-struktur som inneholder et vektorfelt:

bruk serde:: Deserialize;
#[derive (Deserialize)]
strukturData {
 tall: Vec<u32>,
}
fnhoved-() {
la json_data = r#"
 {
"tall": [1, 2, 3, 4, 5]
 }
"#;
la data: Data = serde_json:: from_str (json_data).unwrap();
til Antall i data.numbers {
println!("Antall: {}", Antall);
 }
}

De hoved- funksjonen deserialiserer json_data JSON-innhold i data variabel, og løkken skriver ut elementene i vektoren.

Du må sørge for at du har riktige datatyper og identifikatorer for en deserialiseringsprosess.

Serde samvirker med populære Rust Web Frameworks

Serde er et kraftig bibliotek med mange funksjoner og en enkel API for serialisering og deserialisering av data til forskjellige formater.

Serde er bredt adoptert i Rust-økosystemet, og mange populære kasser og rammeverk har innebygd støtte for Serde, inkludert populære nettrammeverk som Actix, Warp og Rocket og database-ORMer som Diesel.