JSON serializavimas ir deserializavimas naudojant rūdis

JSON (JavaScript Object Notation) tapo populiariu duomenų mainų formatu programinėje įrangoje plėtra dėl savo paprastumo, skaitomumo ir plačiai paplitusio įvairių programavimo galimybių kalbomis. JSON yra lengva XML alternatyva, skirta perduoti duomenis tarp serverio ir žiniatinklio programos arba tarp skirtingų programinės įrangos sistemos komponentų.

Vienas iš pagrindinių darbo su JSON aspektų yra serializacijos ir deserializacijos procesas leidžia konvertuoti JSON duomenis į struktūrinį formatą, kurį galite lengvai valdyti savo viduje programas. Dažniausiai, jei norite dirbti su JSON kitomis kalbomis, gali tekti suskirstyti ir deserializuoti JSON duomenis į kalbos įtaisytąsias duomenų struktūras.

Darbo su Serde pradžia

Serde (serializavimas ir deserializavimas) yra plačiai naudojama Rust biblioteka, kuri suteikia pagrindą konvertuoti Rūdžių duomenų struktūros į saugojimo, perdavimo, bendrinimo ir kitus formatus.

„Serde“ leidžia sklandžiai konvertuoti Rust duomenų tipus ir įvairius duomenų mainų formatus, įskaitant JSON, YAML, BSON, CBOR, MessagePack ir kitus.

„Serde“ pagrindinis dėmesys skiriamas tam, kad serializavimo ir serializavimo procesas būtų kuo paprastesnis ir veiksmingesnis, kartu išlaikant stiprias spausdinimo ir saugos funkcijas.

Pridėkite šias direktyvas prie priklausomybės jūsų skyrius Krovinys.toml failą įdiegti ir naudoti Serde kaip trečiosios šalies priklausomybė nuo Cargo.

[priklausomybės]
serde = { versija = "1.0.159", funkcijos = ["išvesti"] }
serde_json = "1.0.96"

Jums reikės abiejų serde ir serde_json dėžės sąveikauti su JSON. The serde crate suteikia pagrindines funkcijas ir serde_json crate yra specifinis „Serde“ diegimas, skirtas darbui su JSON.

Štai kaip galite importuoti serde_json dėžė ir Serializuoti ir Deserializuoti moduliai iš serde dėžė:

naudoti serde::{Serializuoti, Deserializuoti};
naudoti serde_json;

Apskritai „Serde“ yra galingas įrankis, kurio jums prireiks savo kūrimo arsenale, jei dirbate su JSON „Rust“.

Duomenų serializavimas naudojant Serde

JSON serializacijos procesas apima Rust tipo (priskirto arba įmontuoto) konvertavimą į JSON kitoms operacijoms. „Serde“ pateikia atributų rinkinį, kurį galite naudoti su „Rust struct“, kad būtų galima tiksliai valdyti serializacijos procesą, įskaitant #[išvesti (serializuoti)] atributas, leidžiantis generuoti duomenų struktūrų serializacijos kodą ir konvertuoti Rust struktūrą į JSON.

Apsvarstykite šią struktūrą, vaizduojančią asmens biologinius duomenis; štai kaip galite importuoti ir naudoti Serializuoti atributas struktūroje:

naudoti serde::{Serializuoti, Deserializuoti};
naudoti serde_json;
#[išvesti (serializuoti)]
struktūraAsmuo {
 vardas: Styga,
 amžius: u32,
}

Anotuojant Asmuo statyti su [#derive (serializuoti)], jūs liepiate „Serde“ sugeneruoti reikiamą serializacijos kodą Asmuo struktūra automatiškai.

Štai kaip galite serijiniu būdu sudaryti egzempliorių Asmuo struktūra į JSON:

naudoti serde::{Serializuoti};
naudoti serde_json;
fnpagrindinis() {
// Asmens struktūros egzemplioriaus deklaracija su pavadinimo ir amžiaus laukais
leisti asmuo = asmuo {
 vardas: "Chukwuemeriwo".to_string(),
 amžius: 28,
 };
// nuosekliai sujungia asmens struktūrą į JSON, naudodamas serde_json biblioteką
leisti json = serde_json:: to_string(&person).expect("Serializavimas nepavyko");
// spausdina nuoseklią JSON eilutę
println!(„Serializuotas JSON: {}“, json);
}

Viduje pagrindinis funkcija, serde_json crate serializuoja asmuo objektas. The to_string funkcija naudoja nuorodą į asmuo objektą ir grąžina JSON eilutę, vaizduojančią nuosekliuosius duomenis.

Galiausiai, pagrindinis funkcija išspausdina nuoseklųjį JSON į konsolę.

The serde ir serde_json yra universalūs, taip pat galite suskirstyti masyvus su serde.

naudoti serde::{Serializuoti, Deserializuoti};
naudoti serde_json;
#[išvesti (serializuoti)]
struktūraKoordinatės {
 x: f32,
 y: f32,
}
fnpagrindinis() {
leisti taškai = vec![ 
 Koordinatės { x: 1.0, y: 2.0 },
 Koordinatės { x: 3.5, y: 4.5 },
 ];
leisti json = serde_json:: to_string(&points).expect("Serializavimas nepavyko"); 
println!(„Serializuotas JSON: {}“, json); // Išspausdinkite serijinę JSON eilutę
}

The taškų kintamasis yra vektorius Koordinatės struktūras, vaizduojančias taškus plokštumoje. Taikant Serializuoti priskirti prie Koordinatės struct leidžia be vargo suskirstyti vektorių į JSON.

Be to, galite suskirstyti sąrašus į JSON su serde kaip jūs nuosekliai išdėstote struktūras ir vektorius.

naudoti serde::{Serializuoti, Deserializuoti};
naudoti serde_json;
#[išvesti (serializuoti, serializuoti)]
enumGyvūnas {
 Šuo(Styga),
 Katė(u32),
 Paukštis,
}
fnpagrindinis() {
leisti šuo = gyvūnas:: šuo ("Surūdijęs".to_string());
leisti json = serde_json:: to_string(&šuo).expect("Serializavimas nepavyko");
println!(„Serializuotas JSON: {}“, json);
}

Priklausomai nuo varianto, serializacijos procesas atitinkamai prisitaiko (šiuo atveju Gyvūnas:: Šuo variantas apima a Styga lauką, kurį „Serde“ suskirstys kaip JSON eilutę).

Duomenų serializavimas naudojant Serde

JSON deserializavimas yra JSON duomenų transformavimo į programavimo kalbos vietinius duomenų tipus procesas. „Serde“ suteikia išsamią JSON deserializavimo sistemą, kuri veikia daugumoje integruotų duomenų tipų.

Panašiai kaip serializavimas, „Serde“ siūlo atributus, kuriuos galite naudoti norėdami komentuoti „Rust“ struktūras deserializacijos procesui. Du dažniausiai naudojami serializavimo atributai yra #[išvesti (serializuoti)] ir #[serde (pervardyti = "json_field_name")] atributai.

The #[išvesti (serializuoti)] atributas automatiškai išveda jūsų deserializacijos įgyvendinimą Rūdžių konstrukcijų tipai, kol #[serde (pervardyti = "json_field_name")] atributas leidžia susieti struktūrinius laukus su atitinkamais JSON laukų pavadinimais.

Štai kaip galite deserializuoti JSON duomenis į tinkintą struktūros tipą naudodami Serde:

naudoti serde:: Deserializuoti;
naudoti serde_json;
// apibrėžia asmens, turinčio deserializavimo bruožą, struktūrą iš Serde
#[išvesti (serializuoti)]
struktūraAsmuo {
#[serde (pervardyti = "vardas")]// pervadina lauką į "pavadinimas" 
 pilnas vardas: Styga, 
 amžius: u32,
}
fnpagrindinis() {
leisti json_data = r#"
 {
"vardas": "Jonas Doe",
"amžius": 30
 }
"#;
// deserializuoja JSON duomenis į asmens struktūrą 
leisti asmuo: Asmuo = serde_json:: from_str (json_data).unwrap();
// Atspausdinkite visą asmens vardą ir amžių
println!("Vardas: {}", asmuo.visas_vardas);
println!("Amžius: {}", asmuo.amžius);
}

Anotuojant Asmuo statyti su #[išvesti (serializuoti)] atributas, nurodote, kad Serde gali deserializuoti struktūrą iš JSON. The #[serde (pervardyti = "vardas")] atributų žemėlapiai vardas JSON lauke į pilnas vardas lauke.

The from_str funkcija deserializuoja json_data kintamasis į asmuo objektas ir pagrindinis funkcija spausdina laukus į konsolę.

„Serde“ palaiko įvairių „Rust“ duomenų tipų, įskaitant primityvius tipus, enums, įdėtas struktūras ir kolekcijas, deserializavimą.

Štai kaip galite deserializuoti JSON masyvą į Rust struktūrą, kurioje yra vektoriaus laukas:

naudoti serde:: Deserializuoti;
#[išvesti (serializuoti)]
struktūraDuomenys {
 skaičiai: Sen<u32>,
}
fnpagrindinis() {
leisti json_data = r#"
 {
"skaičiai": [1, 2, 3, 4, 5]
 }
"#;
leisti duomenys: Duomenys = serde_json:: from_str (json_data).unwrap();
dėl numerį in data.numbers {
println!("Skaičius: {}", numeris);
 }
}

The pagrindinis funkcija deserializuoja json_data JSON turinį į duomenis kintamasis, o ciklas spausdina elementus vektoriuje.

Turite įsitikinti, kad turite tinkamus duomenų tipus ir identifikatorius deserializacijos procesui.

„Serde“ sąveikauja su populiariais „Rust“ žiniatinklio rėmais

„Serde“ yra galinga biblioteka, turinti daug funkcijų ir paprastą API, skirtą duomenų nuoseklumui ir serializavimui į skirtingus formatus.

„Serde“ yra plačiai naudojamas Rust ekosistemoje, o daugelis populiarių dėžių ir rėmų yra įmontuoti Serde palaikymas, įskaitant populiarias žiniatinklio sistemas, tokias kaip Actix, Warp ir Rocket, ir duomenų bazių ORM, pvz Dyzelinas.