JSON-serialisering og deserialisering med rust

JSON (JavaScript Object Notation) er dukket op som et populært dataudvekslingsformat i software udvikling på grund af dens enkelhed, læsbarhed og udbredte støtte på tværs af forskellige programmeringer Sprog. JSON er et letvægtsalternativ til XML til overførsel af data mellem en server og en webapplikation eller mellem forskellige softwaresystemkomponenter.

Et af nøgleaspekterne ved at arbejde med JSON er processen med serialisering og deserialisering giver dig mulighed for at konvertere JSON-data til et struktureret format, som du nemt kan manipulere i din programmer. De fleste gange, hvis du vil arbejde med JSON på andre sprog, skal du muligvis serialisere og deserialisere JSON-dataene til sprogets indbyggede datastrukturer.

Kom godt i gang med Serde

Serde (serialisering og deserialisering) er et meget brugt Rust-bibliotek, der giver en ramme til konvertering Rustdatastrukturer til formater til lagring, transmission, deling og andre.

Serde muliggør problemfri konvertering mellem Rust-datatyper og forskellige dataudvekslingsformater, herunder JSON, YAML, BSON, CBOR, MessagePack og andre.

Serdes primære fokus er at gøre serialiserings- og deserialiseringsprocessen så enkel og effektiv som muligt og samtidig bibeholde stærke skrive- og sikkerhedsfunktioner.

Tilføj disse direktiver til afhængigheder afsnit af din Cargo.toml fil til at installere og bruge Serde som en tredjepartsafhængighed med Cargo.

[afhængigheder]
serde = { version = "1.0.159", funktioner = ["aflede"] }
serde_json = "1.0.96"

Du skal bruge både serde og serde_json kasser til at interagere med JSON. Det serde kasse giver kernefunktionerne, og serde_json crate er en specifik implementering af Serde til at arbejde med JSON.

Sådan kan du importere serde_json kasse og Serialiser og Deserialiser moduler fra serde kasse:

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

Samlet set er Serde et kraftfuldt værktøj, du får brug for i dit udviklingsarsenal, hvis du arbejder med JSON i Rust.

Dataserialisering med Serde

JSON-serialiseringsprocessen indebærer konvertering af en Rust-type (brugerdefineret eller indbygget) til JSON til andre operationer. Serde giver et sæt attributter, du kan bruge med Rust struct for at muliggøre præcis kontrol over serialiseringsprocessen, inklusive #[aflede (Serialize)] attribut, der giver dig mulighed for at generere serialiseringskode til dine datastrukturer og konvertere din Rust-struktur til JSON.

Overvej, at denne struktur repræsenterer en persons biodata; her er, hvordan du kan importere og bruge Serialiser attribut på strukturen:

brug serde::{Serialize, Deserialize};
brug serde_json;
#[aflede (Serialize)]
strukturPerson {
 navn: Snor,
 alder: u32,
}

Ved at kommentere Person struktur med [#derive (Serialize)], du beder Serde om at generere den nødvendige serialiseringskode til Person strukturer automatisk.

Her er, hvordan du kan serialisere en forekomst af Person struct til JSON:

brug serde::{Serialize};
brug serde_json;
fnvigtigste() {
// erklæring om Person struct-forekomsten med felterne navn og alder
lade person = Person {
 navn: "Chukwuemeriwo".to_string(),
 alder: 28,
 };
// serialiserer personstrukturen til JSON ved hjælp af serde_json-biblioteket
lade json = serde_json:: to_string(&person).expect("Serialisering mislykkedes");
// udskriver den serialiserede JSON-streng
println!("Serialiseret JSON: {}", json);
}

I den vigtigste funktion, den serde_json kasse serialiserer person objekt. Det til_streng funktion tager en reference til person objekt og returnerer en JSON-streng, der repræsenterer de serialiserede data.

Endelig vigtigste funktion udskriver den serialiserede JSON til konsollen.

Det serde og serde_json er alsidige, kan du også serialisere arrays med serde.

brug serde::{Serialize, Deserialize};
brug serde_json;
#[aflede (Serialize)]
strukturKoordinater {
 x: f32,
 y: f32,
}
fnvigtigste() {
lade point = vec![ 
 Koordinater { x: 1.0, y: 2.0 },
 Koordinater { x: 3.5, y: 4.5 },
 ];
lade json = serde_json:: to_string(&points).expect("Serialisering mislykkedes"); 
println!("Serialiseret JSON: {}", json); // Udskriv den serialiserede JSON-streng
}

Det point variabel er en vektor af Koordinater strukturer, der repræsenterer punkter på et plan. Anvendelse af Serialiser attribut til Koordinater struct giver dig mulighed for ubesværet at serialisere vektoren til JSON.

Derudover kan du serialisere enums til JSON med serde ligesom du serialiserer strukturer og vektorer.

brug serde::{Serialize, Deserialize};
brug serde_json;
#[aflede (Serialize, Deserialize)]
enumDyr {
 Hund(Snor),
 Kat(u32),
 Fugl,
}
fnvigtigste() {
lade hund = Dyr:: Hund("Rusten".to_string());
lade json = serde_json:: to_string(&dog).expect("Serialisering mislykkedes");
println!("Serialiseret JSON: {}", json);
}

Afhængigt af varianten tilpasses serialiseringsprocessen i overensstemmelse hermed (i dette tilfælde Dyr:: Hund variant inkluderer en Snor felt, som Serde vil serialisere som en JSON-streng).

Dataserialisering med Serde

JSON-deserialisering er processen med at transformere JSON-data til native datatyper i et programmeringssprog. Serde giver en omfattende ramme for JSON-deserialisering, der fungerer på de fleste indbyggede datatyper.

I lighed med serialisering tilbyder Serde attributter, som du kan bruge til at annotere dine Rust-strukturer til deserialiseringsprocessen. To almindeligt anvendte attributter til serialisering er #[aflede (Deserialize)] og #[serde (omdøb = "json_field_name")] egenskaber.

Det #[aflede (Deserialize)] attribut udleder automatisk deserialiseringsimplementeringen for din Ruststrukturtyper, mens #[serde (omdøb = "json_field_name")] attribut giver dig mulighed for at tilknytte struct-felter til tilsvarende JSON-feltnavne.

Sådan kan du deserialisere JSON-data til en brugerdefineret strukturtype med Serde:

brug serde:: Deserialize;
brug serde_json;
// definerer en struktur for Person med Deserialize-egenskaben fra Serde
#[aflede (Deserialize)]
strukturPerson {
#[serde (omdøb = "navn")]// omdøber feltet til "navn" 
 fulde navn: Snor, 
 alder: u32,
}
fnvigtigste() {
lade json_data = r#"
 {
"navn": "John Doe",
"alder": 30
 }
"#;
// deserialiserer JSON-dataene til en personstruktur 
lade person: Person = serde_json:: from_str (json_data).unwrap();
// Udskriv personens fulde navn og alder
println!("Navn: {}", person.fuldt_navn);
println!("Alder: {}", person.alder);
}

Ved at kommentere Person struktur med #[aflede (Deserialize)] attribut, angiver du, at Serde kan deserialisere strukturen fra JSON. Det #[serde (omdøb = "navn")] attribut kortlægger navn feltet i JSON til fulde navn Mark.

Det fra_str funktion deserialiserer json_data variabel ind i person objekt, og vigtigste funktion udskriver felterne til konsollen.

Serde understøtter deserialisering på forskellige Rust-datatyper, herunder primitive typer, enums, indlejrede strukturer og samlinger.

Sådan kan du deserialisere et JSON-array til en Rust-struktur, der indeholder et vektorfelt:

brug serde:: Deserialize;
#[aflede (Deserialize)]
strukturData {
 tal: Vec<u32>,
}
fnvigtigste() {
lade json_data = r#"
 {
"tal": [1, 2, 3, 4, 5]
 }
"#;
lade data: Data = serde_json:: from_str (json_data).unwrap();
til nummer i data.numbers {
println!("Nummer: {}", nummer);
 }
}

Det vigtigste funktion deserialiserer json_data JSON-indhold i data variabel, og løkken udskriver elementerne i vektoren.

Du skal sikre dig, at du har de rigtige datatyper og identifikatorer til en deserialiseringsproces.

Serde interopererer med populære rustwebrammer

Serde er et kraftfuldt bibliotek med mange funktioner og en simpel API til at serialisere og deserialisere data til forskellige formater.

Serde er bredt udbredt i Rust-økosystemet, og mange populære kasser og rammer har indbygget understøttelse af Serde, herunder populære web-frameworks som Actix, Warp og Rocket og database-ORM'er som Diesel.