JSON-serialisointi ja deserialisointi ruosteen kanssa

JSON (JavaScript Object Notation) on noussut suosituksi tiedonsiirtomuodoksi ohjelmistoissa kehitystä sen yksinkertaisuuden, luettavuuden ja laajan tuen ansiosta eri ohjelmoinnissa Kieli (kielet. JSON on kevyt vaihtoehto XML: lle tiedon siirtämiseen palvelimen ja verkkosovelluksen välillä tai eri ohjelmistojärjestelmän komponenttien välillä.

Yksi JSON-työskentelyn tärkeimmistä näkökohdista on serialisointi ja deserialisointi, joka avulla voit muuntaa JSON-tiedot jäsenneltyyn muotoon, jota voit helposti muokata omassasi ohjelmia. Useimmiten, jos haluat työskennellä JSON: n kanssa muilla kielillä, saatat joutua sarjoittamaan ja sarjoittamaan JSON-tiedot kielen sisäänrakennetuiksi tietorakenteiksi.

Serden käytön aloittaminen

Serde (serialisointi ja deserialisointi) on laajalti käytetty Rust-kirjasto, joka tarjoaa puitteet muuntamiseen Ruostetietorakenteet tallennus-, lähetys-, jakamis- ja muihin muotoihin.

Serde mahdollistaa saumattoman muuntamisen Rust-tietotyyppien ja erilaisten tiedonsiirtomuotojen välillä, mukaan lukien JSON, YAML, BSON, CBOR, MessagePack ja muut.

Serden ensisijaisena tavoitteena on tehdä sarjoittelu- ja deserialisointiprosessista mahdollisimman yksinkertainen ja tehokas säilyttäen samalla vahvat kirjoitus- ja turvallisuusominaisuudet.

Lisää nämä ohjeet kohtaan riippuvuuksia osa sinun Cargo.toml tiedosto asennettavaksi ja käytettäväksi Serde kuten a kolmannen osapuolen riippuvuus Cargon kanssa.

[riippuvuudet]
serde = { versio = "1.0.159", ominaisuuksia = ["johtaa"] }
serde_json = "1.0.96"

Tarvitset molemmat serde ja serde_json laatikoita vuorovaikutukseen JSONin kanssa. The serde crate tarjoaa ydintoiminnot ja serde_json crate on Serden erityinen toteutus JSON-työskentelyä varten.

Näin voit tuoda serde_json laatikko ja Sarjallistaa ja Deserialoi moduulit serde laatikko:

käyttää serde::{Serialize, Deserialize};
käyttää serde_json;

Kaiken kaikkiaan Serde on tehokas työkalu, jota tarvitset kehitysarsenaalissasi, jos työskentelet JSONin kanssa Rustissa.

Tietojen serialisointi Serden kanssa

JSON-serialisointiprosessi edellyttää Rust-tyypin (mukautetun tai sisäänrakennetun) muuntamisen JSONiksi muita toimintoja varten. Serde tarjoaa joukon attribuutteja, joita voit käyttää Rust-rakenteen kanssa mahdollistaaksesi tarkan hallinnan sarjoituksessa, mukaan lukien #[johdata (sarja)] attribuutti, jonka avulla voit luoda serialisointikoodin tietorakenteillesi ja muuntaa Rust-rakenteen JSON-muotoon.

Harkitse tätä rakennetta, joka edustaa henkilön biodataa; näin voit tuoda ja käyttää Sarjallistaa rakenteen attribuutti:

käyttää serde::{Serialize, Deserialize};
käyttää serde_json;
#[johdata (sarja)]
structHenkilö {
 nimi: merkkijono,
 ikä: u32,
}

Merkitsemällä muistiin Henkilö rakentaa kanssa [#derive (sarja)], pyydät Serdea luomaan tarvittavan sarjouskoodin Henkilö rakentaa automaattisesti.

Näin voit sarjoittaa esiintymän Henkilö struct JSONiin:

käyttää serde::{Serialize};
käyttää serde_json;
fnpää() {
// Person struct -ilmentymän ilmoitus nimi- ja ikäkentillä
antaa henkilö = henkilö {
 nimi: "Chukwuemeriwo".to_string(),
 ikä: 28,
 };
// sarjoittaa henkilörakenteen JSON-muotoon serde_json-kirjaston avulla
antaa json = serde_json:: to_string(&person).expect("Serialisointi epäonnistui");
// tulostaa sarjoitetun JSON-merkkijonon
println!("Sarjoitettu JSON: {}", json);
}

Vuonna pää toiminto, serde_json crate sarjoittaa henkilö esine. The merkkijonoon toiminto viittaa siihen henkilö objektin ja palauttaa JSON-merkkijonon, joka edustaa sarjoitettuja tietoja.

Lopuksi, pää toiminto tulostaa sarjoitetun JSONin konsoliin.

The serde ja serde_json ovat monipuolisia, voit myös sarjoittaa taulukoita serden kanssa.

käyttää serde::{Serialize, Deserialize};
käyttää serde_json;
#[johdata (sarja)]
structKoordinaatit {
 x: f32,
 v: f32,
}
fnpää() {
antaa pisteet = vec![ 
 Koordinaatit { x: 1.0, y: 2.0 },
 Koordinaatit { x: 3.5, y: 4.5 },
 ];
antaa json = serde_json:: to_string(&points).expect("Serialisointi epäonnistui"); 
println!("Sarjoitettu JSON: {}", json); // Tulosta sarjoitettu JSON-merkkijono
}

The pisteitä muuttuja on vektori Koordinaatit rakenteet, jotka edustavat tason pisteitä. Sovelletaan Sarjallistaa ominaisuus Koordinaatit struct mahdollistaa vektorin sarjoituksen JSON-muotoon vaivattomasti.

Lisäksi voit sarjoittaa enumeja JSON-muotoon serde kuten sarjoittaisit rakenteita ja vektoreita.

käyttää serde::{Serialize, Deserialize};
käyttää serde_json;
#[johdella (sarjoittaa, sarjottaa)]
enumEläin {
 Koira(merkkijono),
 Kissa(u32),
 Lintu,
}
fnpää() {
antaa koira = Eläin:: Koira("Ruosteinen".to_string());
antaa json = serde_json:: to_string(&dog).expect("Serialisointi epäonnistui");
println!("Sarjoitettu JSON: {}", json);
}

Vaihteesta riippuen serialisointiprosessi mukautuu vastaavasti (tässä tapauksessa Eläin:: Koira variantti sisältää a merkkijono kenttä, jonka Serde sarjoittaa JSON-merkkijonona).

Tietojen sarjoittaminen Serden kanssa

JSON-deserialisointi on prosessi, jossa JSON-tiedot muunnetaan ohjelmointikielen alkuperäisiksi tietotyypeiksi. Serde tarjoaa kattavan kehyksen JSON-sarjanpoistolle, joka toimii useimmissa sisäänrakennetuissa tietotyypeissä.

Sarjaamisen tapaan Serde tarjoaa attribuutteja, joiden avulla voit merkitä Rust-rakenteisi deserialisointiprosessia varten. Kaksi yleisesti käytettyä attribuuttia sarjoituksessa ovat #[johdella (serialize)] ja #[serde (nimeä uudelleen = "json_field_name")] attribuutteja.

The #[johdella (serialize)] attribuutti johtaa automaattisesti deserialisoinnin toteutuksen Ruosterakennetyypit, samalla kun #[serde (nimeä uudelleen = "json_field_name")] attribuutin avulla voit kartoittaa struct-kentät vastaaviin JSON-kenttien nimiin.

Näin voit sarjoittaa JSON-tiedot mukautetuksi rakennetyypiksi Serden avulla:

käyttää serde:: Deserialize;
käyttää serde_json;
// määrittää rakenteen henkilölle, jolla on Serden Deserialize-ominaisuus
#[johdella (serialize)]
structHenkilö {
#[serde (nimeä uudelleen = "nimi")]// nimeää kentän uudelleen "nimi" 
 koko nimi: merkkijono, 
 ikä: u32,
}
fnpää() {
antaa json_data = r#"
 {
"nimi": "John Doe",
"ikä": 30
 }
"#;
// deserialisoi JSON-tiedot Person-rakenteeksi 
antaa henkilö: Henkilö = serde_json:: from_str (json_data).unwrap();
// Tulosta henkilön koko nimi ja ikä
println!("Nimi: {}", henkilö.koko_nimi);
println!("Ikä: {}", henkilö.ikä);
}

Merkitsemällä muistiin Henkilö rakentaa kanssa #[johdella (serialize)] attribuutti, osoitat, että Serde voi deserialisoida rakenteen JSONista. The #[serde (nimeä uudelleen = "nimi")] attribuutti kartoittaa nimi JSON-kenttään koko nimi ala.

The from_str funktio deserialisoi json_data muuttuja osaksi henkilö esine, ja pää toiminto tulostaa kentät konsoliin.

Serde tukee useiden Rust-tietotyyppien deserialisointia, mukaan lukien primitiivityypit, enumit, sisäkkäiset rakenteet ja kokoelmat.

Näin voit deserialisoida JSON-taulukon Rust-rakenteeksi, joka sisältää vektorikentän:

käyttää serde:: Deserialize;
#[johdella (serialize)]
structData {
 numerot: Vec<u32>,
}
fnpää() {
antaa json_data = r#"
 {
"numerot": [1, 2, 3, 4, 5]
 }
"#;
antaa data: Data = serde_json:: from_str (json_data).unwrap();
varten määrä sisään data.numbers {
println!("Numero: {}", numero);
 }
}

The pää funktio deserialisoi json_data JSON-sisältöä tiedot muuttuja, ja silmukka tulostaa vektorin elementit.

Sinun on varmistettava, että sinulla on oikeat tietotyypit ja tunnisteet sarjoitusta varten.

Serde toimii yhdessä suosittujen Rust-verkkokehysten kanssa

Serde on tehokas kirjasto, jossa on monia ominaisuuksia ja yksinkertainen API tietojen sarjoittamista ja sarjoittamista eri muotoihin.

Serde on laajalti käytössä Rust-ekosysteemissä, ja monissa suosituissa laatikoissa ja kehyksissä on sisäänrakennettu tuki Serdelle, mukaan lukien suositut verkkokehykset, kuten Actix, Warp ja Rocket, sekä tietokanta-ORM: t, kuten Diesel.