JSON serializācija un deserializācija ar rūsu

JSON (JavaScript Object Notation) ir kļuvis par populāru datu apmaiņas formātu programmatūrā attīstība, pateicoties tās vienkāršībai, lasāmībai un plašajam atbalstam dažādās programmās valodas. JSON ir viegla alternatīva XML datu pārsūtīšanai starp serveri un tīmekļa lietojumprogrammu vai starp dažādiem programmatūras sistēmas komponentiem.

Viens no galvenajiem aspektiem darbā ar JSON ir serializācijas un deserializācijas process, kas ļauj konvertēt JSON datus strukturētā formātā, ar kuru varat viegli manipulēt savā ierīcē programmas. Vairumā gadījumu, ja vēlaties strādāt ar JSON citās valodās, iespējams, būs jāserializē un jādeserializē JSON dati valodas iebūvētajās datu struktūrās.

Darba sākšana ar Serde

Serde (serializācija un deserializācija) ir plaši izmantota Rust bibliotēka, kas nodrošina ietvaru konvertēšanai Rūsas datu struktūras glabāšanas, pārraides, koplietošanas un citos formātos.

Serde nodrošina nemanāmu pārveidošanu starp Rust datu tipiem un dažādiem datu apmaiņas formātiem, tostarp JSON, YAML, BSON, CBOR, MessagePack un citiem.

Serde galvenais mērķis ir padarīt serializācijas un deserializācijas procesu pēc iespējas vienkāršāku un efektīvāku, vienlaikus saglabājot spēcīgas rakstīšanas un drošības funkcijas.

Pievienojiet šīs direktīvas atkarības jūsu sadaļa Krava.toml failu instalēšanai un lietošanai Serde kā trešās puses atkarība no Cargo.

[atkarības]
serde = { versija = "1.0.159", funkcijas = ["atvasināt"] }
serde_json = "1.0.96"

Jums būs nepieciešami abi serde un serde_json kastes, lai mijiedarbotos ar JSON. The serde crate nodrošina pamatfunkcijas un serde_json crate ir īpaša Serde ieviešana darbam ar JSON.

Lūk, kā jūs varat importēt serde_json kaste un Serializēt un Deserializēt moduļi no serde kaste:

izmantot serde::{Serializēt, Deserializēt};
izmantot serde_json;

Kopumā Serde ir spēcīgs rīks, kas jums būs nepieciešams jūsu izstrādes arsenālā, ja strādājat ar JSON Rust.

Datu serializācija ar Serde

JSON serializācijas process ietver Rust tipa (pielāgota vai iebūvēta) konvertēšanu uz JSON citām darbībām. Serde nodrošina atribūtu kopu, ko varat izmantot ar Rust struct, lai nodrošinātu precīzu serializācijas procesa kontroli, tostarp #[atvasināt (serializēt)] atribūts, kas ļauj ģenerēt serializācijas kodu jūsu datu struktūrām un pārveidot Rust struktūru par JSON.

Apsveriet šo struktūru, kas attēlo personas biodatus; Lūk, kā jūs varat importēt un izmantot Serializēt atribūts uz struktūras:

izmantot serde::{Serializēt, Deserializēt};
izmantot serde_json;
#[atvasināt (serializēt)]
struktūraPersona {
 nosaukums: Stīga,
 vecums: u32,
}

Anotējot Persona strukturēt ar [#derive (serializēt)], jūs sakāt Serde ģenerēt nepieciešamo serializācijas kodu Persona strukturēt automātiski.

Lūk, kā varat serializēt gadījumu Persona struct uz JSON:

izmantot serde::{Serialize};
izmantot serde_json;
fngalvenais() {
// Person struct instances deklarācija ar nosaukuma un vecuma laukiem
ļaut persona = persona {
 nosaukums: "Chukwuemeriwo".to_string(),
 vecums: 28,
 };
// serializē personas struktūru uz JSON, izmantojot bibliotēku serde_json
ļaut json = serde_json:: to_string(&person).expect("Serializācija neizdevās");
// izdrukā serializēto JSON virkni
println!("Serializēts JSON: {}", json);
}

Iekš galvenais funkcija, serde_json crate serializē persona objektu. The to_string funkcija izmanto atsauci uz persona objektu un atgriež JSON virkni, kas attēlo serializētos datus.

Visbeidzot, galvenais funkcija izdrukā serializēto JSON konsolē.

The serde un serde_json ir daudzpusīgi, jūs varat arī serializēt masīvus ar serde.

izmantot serde::{Serializēt, Deserializēt};
izmantot serde_json;
#[atvasināt (serializēt)]
struktūraKoordinātas {
 x: f32,
 y: f32,
}
fngalvenais() {
ļaut punkti = vec![ 
 Koordinātas { x: 1.0, y: 2.0 },
 Koordinātas { x: 3.5, y: 4.5 },
 ];
ļaut json = serde_json:: to_string(&points).expect("Serializācija neizdevās"); 
println!("Serializēts JSON: {}", json); // Drukājiet serializēto JSON virkni
}

The punktus mainīgais ir vektors Koordinātas struktūras, kas attēlo punktus plaknē. Piemērojot Serializēt piedēvēt Koordinātas struct ļauj bez piepūles serializēt vektoru uz JSON.

Turklāt jūs varat serializēt enums uz JSON ar serde tāpat kā jūs serializējat struktūras un vektorus.

izmantot serde::{Serializēt, Deserializēt};
izmantot serde_json;
#[atvasināt (serializēt, deserializēt)]
enumDzīvnieks {
 suns (Stīga),
 kaķis (u32),
 putns,
}
fngalvenais() {
ļaut suns = dzīvnieks:: suns("Sarūsējis".to_string());
ļaut json = serde_json:: to_string(&suns).expect("Serializācija neizdevās");
println!("Serializēts JSON: {}", json);
}

Atkarībā no varianta serializācijas process attiecīgi pielāgojas (šajā gadījumā Dzīvnieks:: Suns variants ietver a Stīga lauks, kuru Serde serializēs kā JSON virkni).

Datu deserializācija ar Serde

JSON deserializācija ir process, kurā JSON dati tiek pārveidoti par programmēšanas valodas vietējiem datu tipiem. Serde nodrošina visaptverošu ietvaru JSON deserializācijai, kas darbojas ar lielāko daļu iebūvēto datu tipu.

Līdzīgi kā serializācija, Serde piedāvā atribūtus, kurus varat izmantot, lai anotētu savas Rust struktūras deserializācijas procesam. Divi serializēšanai parasti izmantotie atribūti ir #[atvasināt (deserializēt)] un #[serde (pārdēvēt = "json_field_name")] atribūti.

The #[atvasināt (deserializēt)] atribūts automātiski iegūst jūsu deserializācijas ieviešanu Rūsas konstrukciju veidi, kamēr #[serde (pārdēvēt = "json_field_name")] atribūts ļauj kartēt struct laukus ar atbilstošiem JSON lauku nosaukumiem.

Tālāk ir norādīts, kā varat deserializēt JSON datus pielāgotā struktūras veidā, izmantojot Serde.

izmantot serde:: Deserializēt;
izmantot serde_json;
// definē struktūru personai ar deserializācijas pazīmi no Serde
#[atvasināt (deserializēt)]
struktūraPersona {
#[serde (pārdēvēt = "vārds")]// pārdēvē lauku uz "nosaukums" 
 pilnais vārds: Stīga, 
 vecums: u32,
}
fngalvenais() {
ļaut json_data = r#"
 {
"vārds": "Džons Dū",
"vecums": 30
 }
"#;
// deserializē JSON datus personas struktūrā 
ļaut persona: Persona = serde_json:: from_str (json_data).unwrap();
// Izdrukājiet pilnu personas vārdu un vecumu
println!("Vārds: {}", persona.pilns_vārds);
println!("Vecums: {}", persona.vecums);
}

Anotējot Persona strukturēt ar #[atvasināt (deserializēt)] atribūts, jūs norādāt, ka Serde var deserializēt struktūru no JSON. The #[serde (pārdēvēt = "vārds")] atribūtu kartes nosaukums laukā JSON uz pilnais vārds lauks.

The from_str funkcija deserializē json_data mainīgais persona objekts un galvenais funkcija izdrukā laukus konsolē.

Serde atbalsta dažādu Rust datu tipu deserializāciju, tostarp primitīvos tipus, enums, ligzdotās struktūras un kolekcijas.

Lūk, kā jūs varat deserializēt JSON masīvu Rust struktūrā, kas satur vektora lauku:

izmantot serde:: Deserializēt;
#[atvasināt (deserializēt)]
struktūraDati {
 cipari: Vec<u32>,
}
fngalvenais() {
ļaut json_data = r#"
 {
"skaitļi": [1, 2, 3, 4, 5]
 }
"#;
ļaut dati: Dati = serde_json:: from_str (json_data).unwrap();
priekš numuru iekšā data.numbers {
println!("Numurs: {}", numurs);
 }
}

The galvenais funkcija deserializē json_data JSON saturu datus mainīgais, un cilpa izdrukā elementus vektorā.

Jums ir jānodrošina, ka jums ir pareizi datu tipi un identifikatori deserializācijas procesam.

Serde sadarbojas ar populārajiem Rust tīmekļa ietvariem

Serde ir jaudīga bibliotēka ar daudzām funkcijām un vienkāršu API datu serializēšanai un deserializēšanai dažādos formātos.

Serde ir plaši izmantota Rust ekosistēmā, un tajā ir iebūvētas daudzas populāras kastes un rāmji atbalsts Serde, tostarp populāras tīmekļa sistēmas, piemēram, Actix, Warp un Rocket, kā arī datu bāzes ORM Dīzelis.