/ / Tuần tự hóa và giải tuần tự hóa JSON với Rust

Tuần tự hóa và giải tuần tự hóa JSON với Rust

JSON (Ký hiệu đối tượng JavaScript) đã nổi lên như một định dạng trao đổi dữ liệu phổ biến trong phát triển phần mềm do tính đơn giản, dễ đọc và hỗ trợ rộng rãi trên nhiều ngôn ngữ lập trình khác nhau. JSON là giải pháp thay thế gọn nhẹ cho XML để truyền dữ liệu giữa máy chủ và ứng dụng web hoặc giữa các thành phần hệ thống phần mềm khác nhau.



Một trong những khía cạnh quan trọng khi làm việc với JSON là quá trình tuần tự hóa và giải tuần tự hóa cho phép bạn chuyển đổi dữ liệu JSON thành định dạng có cấu trúc mà bạn có thể dễ dàng thao tác trong các chương trình của mình. Hầu hết, nếu bạn muốn làm việc với JSON bằng các ngôn ngữ khác, bạn có thể cần tuần tự hóa và giải tuần tự hóa dữ liệu JSON thành cấu trúc dữ liệu tích hợp sẵn của ngôn ngữ.



Bắt đầu với Serde

Serde (tuần tự hóa và giải tuần tự hóa) là một thư viện Rust được sử dụng rộng rãi, cung cấp một khung để chuyển đổi cấu trúc dữ liệu Rust thành các định dạng để lưu trữ, truyền tải, chia sẻ và các định dạng khác.

Serde cho phép chuyển đổi liền mạch giữa các loại dữ liệu Rust và các định dạng trao đổi dữ liệu khác nhau, bao gồm JSON, YAML, BSON, CBOR, MessagePack, v.v.

Trọng tâm chính của Serde là làm cho quy trình tuần tự hóa và giải tuần tự hóa trở nên đơn giản và hiệu quả nhất có thể trong khi vẫn duy trì các tính năng an toàn và đánh máy mạnh mẽ.

Thêm các chỉ thị này vào phụ thuộc phần của bạn Cargo.toml tập tin để cài đặt và sử dụng bánh mì như một sự phụ thuộc của bên thứ ba với Cargo.

 [dependencies]
serde = { version = "1.0.159" , features = ["derive"] }
serde_json = "1.0.96"

Bạn sẽ cần cả hai người chăn bòserde_json thùng để tương tác với JSON. Các người chăn bò thùng cung cấp các chức năng cốt lõi, và serde_json thùng là một triển khai cụ thể của Serde để làm việc với JSON.

Đây là cách bạn có thể nhập serde_json thùng và tuần tự hóakhử lưu huỳnh mô-đun từ người chăn bò thùng:

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

Nhìn chung, Serde là một công cụ mạnh mẽ mà bạn sẽ cần trong kho vũ khí phát triển của mình nếu bạn đang làm việc với JSON trong Rust.

Tuần tự hóa dữ liệu với Serde

Quá trình tuần tự hóa JSON đòi hỏi phải chuyển đổi loại Rust (tùy chỉnh hoặc tích hợp sẵn) thành JSON cho các hoạt động khác. Serde cung cấp một tập hợp các thuộc tính mà bạn có thể sử dụng với cấu trúc Rust để cho phép kiểm soát chính xác quá trình tuần tự hóa, bao gồm #[derive(Serialize)] thuộc tính cho phép bạn tạo mã tuần tự hóa cho cấu trúc dữ liệu của mình và chuyển đổi cấu trúc Rust thành JSON.

Hãy xem xét cấu trúc này đại diện cho dữ liệu sinh học của một người; đây là cách bạn có thể nhập và sử dụng tuần tự hóa thuộc tính trên cấu trúc:

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

#[derive(Serialize)]
struct Person {
    name: String,
    age: u32,
}

Bằng cách chú thích Người cấu trúc với [#derive(Serialize)]bạn đang yêu cầu Serde tạo mã tuần tự hóa cần thiết cho Người cấu trúc tự động.

Đây là cách bạn có thể tuần tự hóa một phiên bản của Người cấu trúc thành JSON:

 use serde::{Serialize};
use serde_json;

fn main() {
    
    let person = Person {
        name: "Chukwuemeriwo".to_string(),
        age: 28,
    };

    
    let json = serde_json::to_string(&person).expect("Serialization failed");

    
    println!("Serialized JSON: {}", json);
}

bên trong chủ yếu chức năng, các serde_json thùng sắp xếp theo thứ tự người sự vật. Các to_string chức năng có một tham chiếu đến người đối tượng và trả về một chuỗi JSON đại diện cho dữ liệu được tuần tự hóa.

cuối cùng chủ yếu chức năng in JSON được tuần tự hóa lên bàn điều khiển.

kết quả của việc in JSON tuần tự hóa

Các người chăn bòserde_json rất linh hoạt, bạn cũng có thể tuần tự hóa các mảng bằng serde.

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

#[derive(Serialize)]
struct Coordinates {
    x: f32,
    y: f32,
}

fn main() {
    let points = vec![
        Coordinates { x: 1.0, y: 2.0 },
        Coordinates { x: 3.5, y: 4.5 },
    ];

    let json = serde_json::to_string(&points).expect("Serialization failed");

    println!("Serialized JSON: {}", json);
}

Các điểm biến là một vectơ của tọa độ cấu trúc biểu diễn các điểm trên mặt phẳng. Áp dụng các tuần tự hóa thuộc tính cho tọa độ struct cho phép bạn tuần tự hóa vectơ thành JSON một cách dễ dàng.

Ngoài ra, bạn có thể tuần tự hóa các enum thành JSON bằng người chăn bò giống như bạn tuần tự hóa các cấu trúc và vectơ.

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

#[derive(Serialize, Deserialize)]
enum Animal {
    Dog(String),
    Cat(u32),
    Bird,
}

fn main() {
    let dog = Animal::Dog("Rusty".to_string());

    let json = serde_json::to_string(&dog).expect("Serialization failed");

    println!("Serialized JSON: {}", json);
}

Tùy thuộc vào biến thể, quy trình lập số sê-ri sẽ điều chỉnh tương ứng (trong trường hợp này, Động vật::Chó biến thể bao gồm một Sợi dây trường mà Serde sẽ tuần tự hóa dưới dạng chuỗi JSON).

Giải tuần tự hóa dữ liệu với Serde

Giải tuần tự hóa JSON là quá trình chuyển đổi dữ liệu JSON thành các kiểu dữ liệu gốc của ngôn ngữ lập trình. Serde cung cấp một khung toàn diện để giải tuần tự hóa JSON hoạt động trên hầu hết các loại dữ liệu tích hợp sẵn.

Tương tự như tuần tự hóa, Serde cung cấp các thuộc tính mà bạn có thể sử dụng để chú thích cấu trúc Rust của mình cho quá trình giải tuần tự hóa. Hai thuộc tính thường được sử dụng để xê-ri hóa là #[derive(Deserialize)]#[serde(rename = “json_field_name”)] thuộc tính.

Các #[derive(Deserialize)] thuộc tính tự động dẫn xuất việc triển khai giải tuần tự hóa cho các loại cấu trúc Rust của bạn, trong khi thuộc tính #[serde(rename = “json_field_name”)] thuộc tính cho phép bạn ánh xạ các trường cấu trúc thành các tên trường JSON tương ứng.

Đây là cách bạn có thể giải tuần tự hóa dữ liệu JSON thành một loại cấu trúc tùy chỉnh với Serde:

 use serde::Deserialize;
use serde_json;


#[derive(Deserialize)]
struct Person {
    #[serde(rename = "name")]
    full_name: String,
    age: u32,
}

fn main() {
    let json_data = r#"
        {
            "name": "John Doe",
            "age": 30
        }
    "#;

    
    let person: Person = serde_json::from_str(json_data).unwrap();

    
    println!("Name: {}", person.full_name);
    println!("Age: {}", person.age);
}

Bằng cách chú thích Người cấu trúc với #[derive(Deserialize)] thuộc tính, bạn cho biết rằng Serde có thể giải tuần tự hóa cấu trúc từ JSON. Các #[serde(rename = “name”)] thuộc tính ánh xạ tên trường trong JSON thành Họ và tên cánh đồng.

Các from_str chức năng deserializes json_data biến thành người đối tượng và chủ yếu chức năng in các trường ra bàn điều khiển.

kết quả in các trường JSON

Serde hỗ trợ giải tuần tự hóa trên nhiều loại dữ liệu Rust khác nhau, bao gồm các loại nguyên thủy, enums, cấu trúc lồng nhau và bộ sưu tập.

Đây là cách bạn có thể giải tuần tự hóa một mảng JSON thành cấu trúc Rust chứa trường vectơ:

 use serde::Deserialize;

#[derive(Deserialize)]
struct Data {
    numbers: Vec<u32>,
}

fn main() {
    let json_data = r#"
        {
            "numbers": [1, 2, 3, 4, 5]
        }
    "#;

    let data: Data = serde_json::from_str(json_data).unwrap();

    for number in data.numbers {
        println!("Number: {}", number);
    }
}

Các chủ yếu chức năng deserializes json_data nội dung JSON vào dữ liệu biến và vòng lặp in các phần tử trong vectơ.

Bạn phải đảm bảo rằng bạn có các loại dữ liệu và số nhận dạng phù hợp cho quy trình khử lưu huỳnh.

Serde là một thư viện mạnh mẽ với nhiều tính năng và một API đơn giản để tuần tự hóa và giải tuần tự hóa dữ liệu thành các định dạng khác nhau.

Serde được áp dụng rộng rãi trong hệ sinh thái Rust và nhiều thùng và khung phổ biến có hỗ trợ tích hợp cho Serde, bao gồm các khung web phổ biến như Actix, Warp và Rocket cũng như các ORM cơ sở dữ liệu như Diesel.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *