Serializace a deserializace JSON s Rust

JSON (JavaScript Object Notation) se objevil jako populární formát pro výměnu dat v softwaru vývoj díky své jednoduchosti, čitelnosti a široké podpoře napříč různými programy jazyky. JSON je odlehčená alternativa k XML pro přenos dat mezi serverem a webovou aplikací nebo mezi různými komponentami softwarového systému.

Jedním z klíčových aspektů práce s JSON je proces serializace a deserializace, který umožňuje převádět data JSON do strukturovaného formátu, se kterým můžete snadno manipulovat ve svém programy. Ve většině případů, pokud chcete pracovat s JSON v jiných jazycích, možná budete muset serializovat a deserializovat data JSON do vestavěných datových struktur jazyka.

Začínáme se Serde

Serde (serializace a deserializace) je široce používaná knihovna Rust, která poskytuje rámec pro konverzi Rez datové struktury do formátů pro ukládání, přenos, sdílení a další.

Serde umožňuje bezproblémovou konverzi mezi datovými typy Rust a různými formáty pro výměnu dat, včetně JSON, YAML, BSON, CBOR, MessagePack a dalších.

Primárním cílem společnosti Serde je maximálně zjednodušit a zefektivnit proces serializace a deserializace při zachování silného psaní a bezpečnostních funkcí.

Přidejte tyto směrnice do závislosti část vašeho Cargo.toml soubor k instalaci a použití Serde jako závislost na třetí straně s Cargo.

[závislosti]
Serde = { verze = "1.0.159", vlastnosti = ["odvodit"] }
serde_json = "1.0.96"

Budete potřebovat obojí Serde a serde_json bedny pro interakci s JSON. The Serde bedna poskytuje základní funkce a serde_json Crate je specifická implementace Serde pro práci s JSON.

Zde je návod, jak můžete importovat serde_json přepravka a Serializovat a Deserializovat moduly z Serde bedna:

použití serde::{Serializovat, Deserializovat};
použití serde_json;

Celkově je Serde mocný nástroj, který budete potřebovat ve svém vývojovém arzenálu, pokud pracujete s JSON v Rustu.

Serializace dat pomocí Serde

Proces serializace JSON zahrnuje převod typu Rust (vlastní nebo vestavěný) na JSON pro další operace. Serde poskytuje sadu atributů, které můžete použít se strukturou Rust, abyste umožnili přesnou kontrolu nad procesem serializace, včetně #[derive (serialize)] atribut, který vám umožní vygenerovat serializační kód pro vaše datové struktury a převést vaši strukturu Rust na JSON.

Zvažte tuto strukturu představující biodata osoby; Zde je návod, jak můžete importovat a používat Serializovat atribut ve struktuře:

použití serde::{Serializovat, Deserializovat};
použití serde_json;
#[derive (serialize)]
strukturovatOsoba {
 název: Tětiva,
 stáří: u32,
}

Anotací Osoba strukturovat s [#derive (serializovat)], říkáte Serde, aby vygeneroval potřebný serializační kód pro Osoba strukturovat automaticky.

Zde je návod, jak můžete serializovat instanci souboru Osoba struktura do JSON:

použití serde::{Serializovat};
použití serde_json;
fnhlavní() {
// deklarace instance struktury Osoba s polem jméno a věk
nechat osoba = Osoba {
 název: "Chukwuemeriwo".to_string(),
 stáří: 28,
 };
// serializuje strukturu osoby do JSON pomocí knihovny serde_json
nechat json = serde_json:: to_string(&person).expect("Serializace se nezdařila");
// vypíše serializovaný řetězec JSON
println!("Serializovaný JSON: {}", json);
}

V hlavní funkce, serde_json bedna serializuje osoba objekt. The do_řetězce funkce bere odkaz na osoba objekt a vrátí řetězec JSON představující serializovaná data.

Konečně, hlavní funkce vytiskne serializovaný JSON do konzoly.

The Serde a serde_json jsou univerzální, můžete také serializovat pole pomocí serde.

použití serde::{Serializovat, Deserializovat};
použití serde_json;
#[derive (serialize)]
strukturovatSouřadnice {
 X: f32,
 y: f32,
}
fnhlavní() {
nechat body = vec![ 
 Souřadnice { x: 1.0, y: 2.0 },
 Souřadnice { x: 3.5, y: 4.5 },
 ];
nechat json = serde_json:: to_string(&points).expect("Serializace se nezdařila"); 
println!("Serializovaný JSON: {}", json); // Vytiskne serializovaný řetězec JSON
}

The body proměnná je vektor Souřadnice struktury představující body v rovině. Uplatnění Serializovat atribut k Souřadnice struct vám umožňuje bez námahy serializovat vektor do JSON.

Kromě toho můžete serializovat výčty do JSON pomocí Serde jako byste serializovali struktury a vektory.

použití serde::{Serializovat, Deserializovat};
použití serde_json;
#[derive (serialize, deserialize)]
enumZvíře {
 Pes(Tětiva),
 Kočka(u32),
 Pták,
}
fnhlavní() {
nechat pes = Zvíře:: Pes("Rezavý".to_string());
nechat json = serde_json:: to_string(&pes).expect("Serializace se nezdařila");
println!("Serializovaný JSON: {}", json);
}

V závislosti na variantě se proces serializace odpovídajícím způsobem přizpůsobí (v tomto případě Zvíře:: Pes varianta zahrnuje a Tětiva pole, které bude Serde serializovat jako řetězec JSON).

Deserializace dat pomocí Serde

Deserializace JSON je proces transformace dat JSON do nativních datových typů programovacího jazyka. Serde poskytuje komplexní rámec pro deserializaci JSON, který funguje na většině vestavěných datových typů.

Podobně jako serializace nabízí Serde atributy, které můžete použít k anotaci svých struktur Rust pro proces deserializace. Dva běžně používané atributy pro serializaci jsou #[derive (deserialize)] a #[serde (rename = "json_field_name")] atributy.

The #[derive (deserialize)] atribut automaticky odvozuje implementaci deserializace pro váš Typy rezavých struktur, zatímco #[serde (rename = "json_field_name")] atribut umožňuje mapovat pole struktur na odpovídající názvy polí JSON.

Zde je návod, jak můžete deserializovat data JSON na vlastní typ struktury pomocí Serde:

použití serde:: Deserializovat;
použití serde_json;
// definuje strukturu pro osobu s vlastností Deserializovat ze Serde
#[derive (deserialize)]
strukturovatOsoba {
#[serde (přejmenovat = "název")]// přejmenuje pole na "name" 
 celé jméno: Tětiva, 
 stáří: u32,
}
fnhlavní() {
nechat json_data = r#"
 {
"název": "John Doe",
"stáří": 30
 }
"#;
// deserializuje data JSON do struktury osoby 
nechat osoba: Osoba = serde_json:: from_str (json_data).unwrap();
// Vytiskne celé jméno a věk osoby
println!("Název: {}", osoba.celé_jméno);
println!("Věk: {}", osoba.věk);
}

Anotací Osoba strukturovat s #[derive (deserialize)] naznačujete, že Serde může deserializovat strukturu z JSON. The #[serde (rename = "jméno")] atribut mapuje název pole v JSON do celé jméno pole.

The od_str funkce deserializuje json_data proměnná do osoba objekt a hlavní funkce vytiskne pole do konzole.

Serde podporuje deserializaci na různých typech dat Rust, včetně primitivních typů, výčtů, vnořených struktur a kolekcí.

Zde je návod, jak můžete deserializovat pole JSON na strukturu Rust obsahující vektorové pole:

použití serde:: Deserializovat;
#[derive (deserialize)]
strukturovatData {
 čísla: Vec<u32>,
}
fnhlavní() {
nechat json_data = r#"
 {
"čísla": [1, 2, 3, 4, 5]
 }
"#;
nechat data: Data = serde_json:: from_str (json_data).unwrap();
pro číslo v data.numbers {
println!("Číslo: {}", číslo);
 }
}

The hlavní funkce deserializuje json_data Obsah JSON do data proměnná a smyčka vytiskne prvky ve vektoru.

Musíte zajistit, že máte správné datové typy a identifikátory pro proces deseralizace.

Serde spolupracuje s populárními Rust Web Frameworks

Serde je výkonná knihovna s mnoha funkcemi a jednoduchým API pro serializaci a deserializaci dat do různých formátů.

Serde je široce adoptován v ekosystému Rust a mnoho populárních beden a rámců má vestavěno podpora pro Serde, včetně populárních webových rámců jako Actix, Warp a Rocket a databázových ORM jako Diesel.