JSON-i serialiseerimine ja deserialiseerimine roostega

JSON (JavaScript Object Notation) on muutunud tarkvaras populaarseks andmevahetuse vorminguks arendus tänu oma lihtsusele, loetavusele ja laialdasele toele erinevates programmeerimistöödes keeled. JSON on kerge alternatiiv XML-ile andmete edastamiseks serveri ja veebirakenduse või erinevate tarkvarasüsteemi komponentide vahel.

Üks JSON-iga töötamise põhiaspekte on serialiseerimise ja deserialiseerimise protsess, mis võimaldab teil teisendada JSON-andmed struktureeritud vormingusse, mida saate hõlpsalt oma sees manipuleerida programmid. Kui soovite töötada JSON-iga teistes keeltes, peate enamasti JSON-i andmed keele sisseehitatud andmestruktuuridesse jada ja deserialiseerima.

Serdega alustamine

Serde (serialiseerimine ja deserialiseerimine) on laialdaselt kasutatav Rusti teek, mis pakub raamistikku teisendamiseks Rooste andmestruktuurid salvestamise, edastamise, jagamise ja muude vormingutesse.

Serde võimaldab sujuvat teisendamist Rusti andmetüüpide ja erinevate andmevahetusvormingute vahel, sealhulgas JSON, YAML, BSON, CBOR, MessagePack ja teised.

Serde peamine eesmärk on muuta seeria- ja deserialiseerimisprotsess võimalikult lihtsaks ja tõhusaks, säilitades samal ajal tugevad tippimis- ja turvafunktsioonid.

Lisage need direktiivid sõltuvused osa teie Cargo.toml faili installimiseks ja kasutamiseks Serde nagu kolmanda osapoole sõltuvus Cargoga.

[sõltuvused]
serde = { versioon = "1.0.159", funktsioonid = ["tuletama"] }
serde_json = "1.0.96"

Teil on vaja mõlemat serde ja serde_json kastid JSON-iga suhtlemiseks. The serde crate pakub põhifunktsioone ja serde_json crate on Serde konkreetne rakendus JSON-iga töötamiseks.

Siit saate teada, kuidas saate importida serde_json kast ja Serialiseerida ja Deserialiseerida moodulid alates serde kast:

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

Üldiselt on Serde võimas tööriist, mida vajate oma arendusarsenalis, kui töötate JSON-iga Rustis.

Andmete serialiseerimine Serdega

JSON-i serialiseerimisprotsess hõlmab Rust-tüübi (kohandatud või sisseehitatud) teisendamist JSON-iks muude toimingute jaoks. Serde pakub atribuutide komplekti, mida saate kasutada koos Rust structiga, et võimaldada täpset juhtimist serialiseerimisprotsessi üle, sealhulgas #[tuletada (seeria)] atribuut, mis võimaldab teil luua oma andmestruktuuride jaoks serialiseerimiskoodi ja teisendada Rust-struktuuri JSON-iks.

Mõelge sellele struktuurile, mis esindab isiku bioandmeid; Siit saate teada, kuidas saate importida ja kasutada Serialiseerida atribuut struktuuril:

kasutada serde::{Serialize, Deserialize};
kasutada serde_json;
#[tuletada (seeria)]
struktuurIsik {
 nimi: String,
 vanus: u32,
}

Märkides Isik konstrueerida koos [#derive (seeria)], käsite Serdel genereerida selle jaoks vajalik serialiseerimiskood Isik struktureerida automaatselt.

Siit saate teada, kuidas saate eksemplari järjestada Isik JSON-i struktuur:

kasutada serde::{Serialize};
kasutada serde_json;
fnpeamine() {
// Isiku struktuuri eksemplari deklaratsioon nime ja vanuse väljadega
lase isik = isik {
 nimi: "Chukwuemeriwo".to_string(),
 vanus: 28,
 };
// serialiseerib isikustruktuuri serde_jsoni teeki kasutades JSON-iks
lase json = serde_json:: to_string(&person).expect("Serialiseerimine ebaõnnestus");
// prindib serialiseeritud JSON-stringi
println!("Serialiseeritud JSON: {}", json);
}

Aastal peamine funktsioon, serde_json crate seriaaliseerib inimene objektiks. The to_string funktsioon viitab sellele inimene objekti ja tagastab JSON-stringi, mis esindab jadaandmeid.

Lõpuks, peamine funktsioon prindib serialiseeritud JSON-i konsooli.

The serde ja serde_json on mitmekülgsed, saate ka serde abil massiive järjestada.

kasutada serde::{Serialize, Deserialize};
kasutada serde_json;
#[tuletada (seeria)]
struktuurKoordinaadid {
 x: f32,
 y: f32,
}
fnpeamine() {
lase punktid = vec![ 
 Koordinaadid { x: 1.0, y: 2.0 },
 Koordinaadid { x: 3.5, y: 4.5 },
 ];
lase json = serde_json:: to_string(&points).expect("Serialiseerimine ebaõnnestus"); 
println!("Serialiseeritud JSON: {}", json); // Prinditakse serialiseeritud JSON-string
}

The punktid muutuja on vektor Koordinaadid tasapinna punkte esindavad struktuurid. Rakendades Serialiseerida omistada Koordinaadid struct võimaldab teil vektori vaevata JSON-iks järjestada.

Lisaks saate enumid JSON-i järjestada serde nagu te järjestate struktuure ja vektoreid.

kasutada serde::{Serialize, Deserialize};
kasutada serde_json;
#[tuletada (seeria, järjestada)]
enumLoom {
 koer (String),
 kass(u32),
 Lind,
}
fnpeamine() {
lase koer = loom:: koer("Roostes".to_string());
lase json = serde_json:: to_string(&koer).expect("Serialiseerimine ebaõnnestus");
println!("Serialiseeritud JSON: {}", json);
}

Olenevalt variandist kohandub serialiseerimisprotsess vastavalt (antud juhul Loom:: Koer variant sisaldab a String välja, mille Serde JSON-stringina järjestab).

Andmete serialiseerimine Serdega

JSON-i deserialiseerimine on protsess, mille käigus JSON-andmed teisendatakse programmeerimiskeele loomulikeks andmetüüpideks. Serde pakub JSON-i deserialiseerimiseks kõikehõlmavat raamistikku, mis töötab enamiku sisseehitatud andmetüüpide puhul.

Sarnaselt serialiseerimisega pakub Serde atribuute, mida saate kasutada deserialiseerimisprotsessis oma Rust-struktuuride märkimiseks. Kaks serialiseerimiseks tavaliselt kasutatavat atribuuti on #[tuletada (serialiseerida)] ja #[serde (ümbernimetamine = "json_field_name")] atribuudid.

The #[tuletada (serialiseerida)] atribuut tuletab automaatselt teie jaoks deserialiseerimise teostuse Roostekonstruktsioonide tüübid, samal ajal kui #[serde (ümbernimetamine = "json_field_name")] atribuut võimaldab vastendada struktuurivälju vastavate JSON-väljanimedega.

Siit saate teada, kuidas saate Serde abil JSON-andmeid kohandatud struktuuritüübiks deserialiseerida.

kasutada serde:: Deserialize;
kasutada serde_json;
// määrab Serde Deserialiseerimise tunnusega isiku struktuuri
#[tuletada (serialiseerida)]
struktuurIsik {
#[serde (ümbernimetamine = "nimi")]// nimetab välja ümber "nimi" 
 täisnimi: String, 
 vanus: u32,
}
fnpeamine() {
lase json_data = r#"
 {
"nimi": "John Doe",
"vanus": 30
 }
"#;
// deserialiseerib JSON-andmed isikustruktuuriks 
lase isik: Isik = serde_json:: from_str (json_data).unwrap();
// Trüki inimese täisnimi ja vanus
println!("Nimi: {}", isik.täisnimi);
println!("Vanus: {}", isik.vanus);
}

Märkides Isik konstrueerida koos #[tuletada (serialiseerida)] atribuut, näitate, et Serde saab JSON-i struktuuri deserialiseerida. The #[serde (ümbernimetamine = "nimi")] atribuut kaardid nimi JSON-i väljale täisnimi valdkonnas.

The from_str funktsioon deserialiseerib json_data muutuja sisse inimene objekt ja peamine funktsioon prindib väljad konsooli.

Serde toetab mitmesuguste Rusti andmetüüpide, sealhulgas primitiivsete tüüpide, enumite, pesastatud struktuuride ja kogude deserialiseerimist.

Siin on, kuidas saate JSON-massiivi deserialiseerida vektorvälja sisaldavaks Rust-struktuuriks.

kasutada serde:: Deserialize;
#[tuletada (serialiseerida)]
struktuurAndmed {
 numbrid: Vec<u32>,
}
fnpeamine() {
lase json_data = r#"
 {
"numbrid": [1, 2, 3, 4, 5]
 }
"#;
lase andmed: Andmed = serde_json:: from_str (json_data).unwrap();
jaoks number sisse data.numbers {
println!("Arv: {}", number);
 }
}

The peamine funktsioon deserialiseerib json_data JSON-i sisu andmeid muutuja ja tsükkel prindib vektori elemendid.

Peate tagama, et teil on deserialiseerimisprotsessi jaoks õiged andmetüübid ja identifikaatorid.

Serde töötab populaarsete Rusti veebiraamistikega

Serde on võimas raamatukogu, millel on palju funktsioone ja lihtne API andmete serialiseerimiseks ja deserialiseerimiseks erinevatesse vormingutesse.

Serde on Rusti ökosüsteemis laialdaselt kasutusele võetud ning paljud populaarsed kastid ja raamistikud on sisseehitatud Serde tugi, sealhulgas populaarsed veebiraamistikud nagu Actix, Warp ja Rocket ning andmebaasi ORM-id nagu Diisel.