JSON serialisering och deserialisering med rost

JSON (JavaScript Object Notation) har dykt upp som ett populärt datautbytesformat i programvara utveckling på grund av dess enkelhet, läsbarhet och breda stöd inom olika programmering språk. JSON är ett lättviktigt alternativ till XML för att överföra data mellan en server och en webbapplikation eller mellan olika programvarusystemkomponenter.

En av de viktigaste aspekterna av att arbeta med JSON är processen för serialisering och deserialisering som låter dig konvertera JSON-data till ett strukturerat format som du enkelt kan manipulera inom din program. De flesta gånger, om du vill arbeta med JSON på andra språk, kan du behöva serialisera och deserialisera JSON-data till språkets inbyggda datastrukturer.

Komma igång med Serde

Serde (serialisering och deserialisering) är ett allmänt använt Rust-bibliotek som tillhandahåller ett ramverk för konvertering Rostdatastrukturer till format för lagring, överföring, delning och annat.

Serde möjliggör sömlös konvertering mellan Rust-datatyper och olika datautbytesformat, inklusive JSON, YAML, BSON, CBOR, MessagePack och andra.

Serdes primära fokus är att göra serialiserings- och deserialiseringsprocessen så enkel och effektiv som möjligt samtidigt som starka skriv- och säkerhetsfunktioner bibehålls.

Lägg till dessa direktiv till beroenden avsnitt av din Cargo.toml fil att installera och använda Serde som en tredje parts beroende med Cargo.

[beroenden]
serde = { version = "1.0.159", funktioner = ["härleda"] }
serde_json = "1.0.96"

Du behöver båda serde och serde_json lådor för att interagera med JSON. De serde crate tillhandahåller kärnfunktionerna och serde_json crate är en specifik implementering av Serde för att arbeta med JSON.

Så här kan du importera serde_json låda och Serialisera och Deserialisera moduler från serde spjällåda:

använda sig av serde::{Serialize, Deserialize};
använda sig av serde_json;

Sammantaget är Serde ett kraftfullt verktyg du behöver i din utvecklingsarsenal om du arbetar med JSON i Rust.

Dataserialisering med Serde

JSON-serialiseringsprocessen innebär att en Rust-typ (anpassad eller inbyggd) konverteras till JSON för andra operationer. Serde tillhandahåller en uppsättning attribut som du kan använda med Rust struct för att möjliggöra exakt kontroll över serialiseringsprocessen, inklusive #[härleda (Serialisera)] attribut som låter dig generera serialiseringskod för dina datastrukturer och konvertera din Rust-struktur till JSON.

Anse att denna struktur representerar en persons biodata; så här kan du importera och använda Serialisera attribut på strukturen:

använda sig av serde::{Serialize, Deserialize};
använda sig av serde_json;
#[härleda (Serialisera)]
strukturPerson {
 namn: Sträng,
 ålder: u32,
}

Genom att kommentera Person strukturera med [#derive (Serialisera)], säger du till Serde att generera den nödvändiga serialiseringskoden för Person strukturera automatiskt.

Så här kan du serialisera en instans av Person struct till JSON:

använda sig av serde::{Serialize};
använda sig av serde_json;
fnhuvud() {
// deklaration av Person struct-instansen med namn och åldersfält
låta person = Person {
 namn: "Chukwuemeriwo".att stränga(),
 ålder: 28,
 };
// serialiserar personstrukturen till JSON med hjälp av serde_json-biblioteket
låta json = serde_json:: to_string(&person).expect("Serialisering misslyckades");
// skriver ut den serialiserade JSON-strängen
println!("Serialized JSON: {}", json);
}

I den huvud funktion, den serde_json crate serialiserar person objekt. De att stränga funktionen tar en referens till person objekt och returnerar en JSON-sträng som representerar serialiserade data.

Slutligen, den huvud funktionen skriver ut den serialiserade JSON till konsolen.

De serde och serde_json är mångsidiga, du kan också serialisera arrayer med serde.

använda sig av serde::{Serialize, Deserialize};
använda sig av serde_json;
#[härleda (Serialisera)]
strukturKoordinater {
 x: f32,
 y: f32,
}
fnhuvud() {
låta poäng = vec![ 
 Koordinater { x: 1.0, y: 2.0 },
 Koordinater { x: 3.5, y: 4.5 },
 ];
låta json = serde_json:: to_string(&points).expect("Serialisering misslyckades"); 
println!("Serialized JSON: {}", json); // Skriv ut den serialiserade JSON-strängen
}

De poäng variabel är en vektor av Koordinater strukturer som representerar punkter på ett plan. Att tillämpa Serialisera attribut till Koordinater struct låter dig serialisera vektorn till JSON utan ansträngning.

Dessutom kan du serialisera enums till JSON med serde som du serialiserar strukturer och vektorer.

använda sig av serde::{Serialize, Deserialize};
använda sig av serde_json;
#[derive (Serialize, Deserialize)]
uppräkningDjur {
 Hund(Sträng),
 Katt(u32),
 Fågel,
}
fnhuvud() {
låta hund = Djur:: Hund("Rostig".att stränga());
låta json = serde_json:: to_string(&dog).expect("Serialisering misslyckades");
println!("Serialized JSON: {}", json);
}

Beroende på varianten anpassas serialiseringsprocessen därefter (i det här fallet Djur:: Hund varianten inkluderar en Sträng som Serde kommer att serialisera som en JSON-sträng).

Dataavserialisering med Serde

JSON-deserialisering är processen att omvandla JSON-data till infödda datatyper för ett programmeringsspråk. Serde tillhandahåller ett omfattande ramverk för JSON-deserialisering som fungerar på de flesta inbyggda datatyper.

I likhet med serialisering erbjuder Serde attribut som du kan använda för att kommentera dina Rust-strukturer för deserialiseringsprocessen. Två vanliga attribut för serialisering är #[härleda (avserialisera)] och #[serde (rename = "json_field_name")] attribut.

De #[härleda (avserialisera)] attribut härleder automatiskt deserialiseringsimplementeringen för din Typer av roststruktur, medan #[serde (rename = "json_field_name")] attribut låter dig mappa struct-fält till motsvarande JSON-fältnamn.

Så här kan du deserialisera JSON-data till en anpassad strukturtyp med Serde:

använda sig av serde:: Deserialisera;
använda sig av serde_json;
// definierar en struktur för Person med egenskapen Deserialize från Serde
#[härleda (avserialisera)]
strukturPerson {
#[serde (byt namn på = "namn")]// byter namn på fältet till "namn" 
 fullständiga namn: Sträng, 
 ålder: u32,
}
fnhuvud() {
låta json_data = r#"
 {
"namn": "John Doe",
"ålder": 30
 }
"#;
// deserialiserar JSON-data till en personstruktur 
låta person: Person = serde_json:: from_str (json_data).unwrap();
// Skriv ut personens fullständiga namn och ålder
println!("Namn: {}", person.fullständigt_namn);
println!("Ålder: {}", person.ålder);
}

Genom att kommentera Person strukturera med #[härleda (avserialisera)] attribut, anger du att Serde kan deserialisera strukturen från JSON. De #[serde (byt namn = "namn")] attribut kartlägger namn fältet i JSON till fullständiga namn fält.

De from_str funktionen avserialiserar json_data variabel till person objekt och huvud funktionen skriver ut fälten till konsolen.

Serde stöder deserialisering på olika Rust-datatyper, inklusive primitiva typer, enums, kapslade strukturer och samlingar.

Så här kan du deserialisera en JSON-array till en Rust-struktur som innehåller ett vektorfält:

använda sig av serde:: Deserialisera;
#[härleda (avserialisera)]
strukturData {
 tal: Vec<u32>,
}
fnhuvud() {
låta json_data = r#"
 {
"tal": [1, 2, 3, 4, 5]
 }
"#;
låta data: Data = serde_json:: from_str (json_data).unwrap();
för siffra i data.numbers {
println!("Siffra: {}", siffra);
 }
}

De huvud funktionen avserialiserar json_data JSON-innehåll i data variabel, och slingan skriver ut elementen i vektorn.

Du måste se till att du har rätt datatyper och identifierare för en deserialiseringsprocess.

Serde samverkar med populära Rust Web Frameworks

Serde är ett kraftfullt bibliotek med många funktioner och ett enkelt API för att serialisera och deserialisera data till olika format.

Serde är allmänt antagen i Rust-ekosystemet, och många populära lådor och ramar har inbyggda stöd för Serde, inklusive populära webbramverk som Actix, Warp och Rocket och databas-ORM Diesel.