Serialisasi JSON dan Deserialisasi Dengan Rust

JSON (JavaScript Object Notation) telah muncul sebagai format pertukaran data yang populer dalam perangkat lunak pengembangan karena kesederhanaan, keterbacaan, dan dukungan luas di berbagai pemrograman bahasa. JSON adalah alternatif ringan untuk XML untuk mentransmisikan data antara server dan aplikasi web atau antara komponen sistem perangkat lunak yang berbeda.

Salah satu aspek kunci bekerja dengan JSON adalah proses serialisasi dan deserialisasi yang memungkinkan Anda mengonversi data JSON menjadi format terstruktur yang dapat Anda manipulasi dengan mudah di dalam program. Sering kali, jika Anda ingin bekerja dengan JSON dalam bahasa lain, Anda mungkin perlu membuat serialisasi dan deserialisasi data JSON ke dalam struktur data bawaan bahasa tersebut.

Memulai Dengan Serde

Serde (serialisasi dan deserialisasi) adalah pustaka Rust yang banyak digunakan yang menyediakan kerangka kerja untuk mengonversi

Struktur data karat ke dalam format untuk penyimpanan, transmisi, berbagi, dan lain-lain.

Serde memungkinkan konversi tanpa batas antara tipe data Rust dan berbagai format pertukaran data, termasuk JSON, YAML, BSON, CBOR, MessagePack, dan lainnya.

Fokus utama Serde adalah membuat proses serialisasi dan deserialisasi sesederhana dan seefisien mungkin dengan tetap mempertahankan fitur pengetikan dan keamanan yang kuat.

Tambahkan arahan ini ke dependencies bagian Anda Kargo.toml file untuk diinstal dan digunakan Serde sebagai ketergantungan pihak ketiga dengan Cargo.

[ketergantungan]
serde = { versi = "1.0.159", fitur = ["memperoleh"] }
serde_json = "1.0.96"

Anda akan membutuhkan keduanya serde Dan serde_json peti untuk berinteraksi dengan JSON. Itu serde peti menyediakan fungsionalitas inti, dan serde_json peti adalah implementasi khusus Serde untuk bekerja dengan JSON.

Inilah cara Anda dapat mengimpor file serde_json peti dan Buat serial Dan Deserialisasi modul dari serde peti:

menggunakan serde::{Serialisasi, Deserialisasi};
menggunakan serde_json;

Secara keseluruhan, Serde adalah alat canggih yang Anda perlukan di gudang pengembangan jika Anda bekerja dengan JSON di Rust.

Serialisasi Data Dengan Serde

Proses serialisasi JSON memerlukan konversi tipe Rust (kustom atau bawaan) ke JSON untuk operasi lain. Serde menyediakan satu set atribut yang dapat Anda gunakan dengan struktur Rust untuk mengaktifkan kontrol yang tepat atas proses serialisasi, termasuk #[turunkan (Serialisasi)] atribut yang memungkinkan Anda menghasilkan kode serialisasi untuk struktur data Anda dan mengubah struktur Rust Anda menjadi JSON.

Pertimbangkan struktur ini yang mewakili biodata seseorang; inilah cara Anda dapat mengimpor dan menggunakan Buat serial atribut pada struct:

menggunakan serde::{Serialisasi, Deserialisasi};
menggunakan serde_json;
#[turunkan (Serialisasi)]
structOrang {
 nama: Rangkaian,
 usia: u32,
}

Dengan memberi anotasi pada Orang struktur dengan [#derive (Serialisasi)], Anda memberi tahu Serde untuk membuat kode serialisasi yang diperlukan untuk Orang struktur secara otomatis.

Inilah cara Anda membuat cerita bersambung sebuah instance dari Orang struct ke JSON:

menggunakan serde::{Serialisasi};
menggunakan serde_json;
fnutama() {
// deklarasi instance struct Person dengan bidang nama dan umur
membiarkan orang = Orang {
 nama: "Chukwuemeriwo".to_string(),
 usia: 28,
 };
// membuat serial orang struct ke JSON menggunakan perpustakaan serde_json
membiarkan json = serde_json:: to_string(&orang).berharap("Serialisasi gagal");
// mencetak string JSON berseri
cetak!("JSON Berseri: {}", json);
}

Dalam utama fungsi, yang serde_json peti membuat serial orang obyek. Itu to_string fungsi mengambil referensi ke orang objek dan mengembalikan string JSON yang mewakili data serial.

Akhirnya, utama fungsi mencetak JSON berseri ke konsol.

Itu serde Dan serde_json serbaguna, Anda juga dapat membuat serial array dengan serde.

menggunakan serde::{Serialisasi, Deserialisasi};
menggunakan serde_json;
#[turunkan (Serialisasi)]
structKoordinat {
 X: f32,
 y: f32,
}
fnutama() {
membiarkan poin = vec![ 
 Koordinat {x: 1.0, y: 2.0 },
 Koordinat {x: 3.5, y: 4.5 },
 ];
membiarkan json = serde_json:: to_string(&points).berharap("Serialisasi gagal"); 
cetak!("JSON Berseri: {}", json); // Cetak string JSON berseri
}

Itu poin variabel adalah vektor dari Koordinat struct yang mewakili titik pada bidang. Menerapkan Buat serial atribut ke Koordinat struct memungkinkan Anda membuat cerita bersambung vektor ke JSON dengan mudah.

Selain itu, Anda dapat membuat cerita bersambung enum menjadi JSON dengan serde seperti Anda membuat cerita bersambung struct dan vektor.

menggunakan serde::{Serialisasi, Deserialisasi};
menggunakan serde_json;
#[turunkan (Serialisasikan, Deserialisasikan)]
enumSatwa {
 Anjing(Rangkaian),
 Kucing(u32),
 Burung,
}
fnutama() {
membiarkan anjing = Hewan:: Anjing("Berkarat".to_string());
membiarkan json = serde_json:: to_string(&anjing).berharap("Serialisasi gagal");
cetak!("JSON Berseri: {}", json);
}

Bergantung pada variannya, proses serialisasi menyesuaikan (dalam hal ini, file Hewan:: Anjing varian termasuk a Rangkaian bidang yang akan diserialkan Serde sebagai string JSON).

Deserialisasi Data Dengan Serde

Deserialisasi JSON adalah proses mengubah data JSON menjadi tipe data asli dari bahasa pemrograman. Serde menyediakan kerangka komprehensif untuk deserialisasi JSON yang berfungsi pada sebagian besar tipe data bawaan.

Mirip dengan serialisasi, Serde menawarkan atribut yang dapat Anda gunakan untuk memberi anotasi pada struktur Rust Anda untuk proses deserialisasi. Dua atribut yang umum digunakan untuk serialisasi adalah #[turunkan (Deserialize)] Dan #[serde (ganti nama = "json_field_name")] atribut.

Itu #[turunkan (Deserialize)] atribut secara otomatis mendapatkan implementasi deserialization untuk Anda Jenis struktur karat, selagi #[serde (ganti nama = "json_field_name")] atribut memungkinkan Anda memetakan bidang struct ke nama bidang JSON yang sesuai.

Inilah cara Anda dapat melakukan deserialisasi data JSON menjadi tipe struct khusus dengan Serde:

menggunakan serde:: Deserialisasi;
menggunakan serde_json;
// mendefinisikan struct untuk Orang dengan sifat Deserialisasi dari Serde
#[turunkan (Deserialize)]
structOrang {
#[serde (ganti nama = "nama")]// mengganti nama bidang menjadi "nama" 
 nama lengkap: Rangkaian, 
 usia: u32,
}
fnutama() {
membiarkan json_data = r#"
 {
"nama": "John Doe",
"usia": 30
 }
"#;
// deserialisasi data JSON menjadi struct Person 
membiarkan orang: Orang = serde_json:: from_str (json_data).unwrap();
// Cetak nama lengkap dan umur orang tersebut
cetak!("Nama: {}", orang.nama_lengkap);
cetak!("Usia: {}", orang.umur);
}

Dengan memberi anotasi pada Orang struktur dengan #[turunkan (Deserialize)], Anda menunjukkan bahwa Serde dapat melakukan deserialisasi struct dari JSON. Itu #[serde (ganti nama = "nama")] atribut memetakan nama bidang di JSON ke nama lengkap bidang.

Itu from_str fungsi deserializes json_data variabel ke dalam orang objek, dan utama fungsi mencetak bidang ke konsol.

Serde mendukung deserialisasi pada berbagai tipe data Rust, termasuk tipe primitif, enum, struktur bersarang, dan koleksi.

Inilah cara Anda membatalkan deserial array JSON ke dalam struktur Rust yang berisi bidang vektor:

menggunakan serde:: Deserialisasi;
#[turunkan (Deserialize)]
structData {
 nomor: Vec<u32>,
}
fnutama() {
membiarkan json_data = r#"
 {
"angka": [1, 2, 3, 4, 5]
 }
"#;
membiarkan data: Data = serde_json:: from_str (json_data).unwrap();
untuk nomor di dalam data.angka {
cetak!("Nomor: {}", nomor);
 }
}

Itu utama fungsi deserializes json_data konten JSON ke dalam data variabel, dan loop mencetak elemen dalam vektor.

Anda harus memastikan bahwa Anda memiliki tipe data dan pengidentifikasi yang tepat untuk proses deserialisasi.

Serde Berinteroperasi Dengan Kerangka Web Rust Populer

Serde adalah perpustakaan yang kuat dengan banyak fitur dan API sederhana untuk serialisasi dan deserialisasi data ke dalam format yang berbeda.

Serde diadopsi secara luas di ekosistem Rust, dan banyak peti serta kerangka kerja populer telah terpasang dukungan untuk Serde, termasuk kerangka kerja web populer seperti Actix, Warp, dan Rocket dan database ORM seperti Diesel.