Rust में JSON के साथ काम करना: पार्सिंग, सीरियलाइज़ेशन और व्यावहारिक उदाहरण

Rust में JSON का परिचय

JSON (JavaScript Object Notation) वेब डेवलपमेंट, कॉन्फ़िगरेशन फ़ाइलों और API में सबसे लोकप्रिय डेटा एक्सचेंज फ़ॉर्मेट में से एक बना हुआ है। Rust भाषा, जो अपने प्रदर्शन और मेमोरी सुरक्षा के लिए जानी जाती है, serde_json क्रेट के माध्यम से JSON के साथ काम करने के लिए शक्तिशाली टूल प्रदान करती है। इस लेख में, हम विस्तार से जानेंगे कि कैसे Rust में आधुनिक दृष्टिकोणों और सर्वोत्तम प्रथाओं का उपयोग करके JSON पार्सिंग और सीरियलाइज़ेशन किया जाए।

serde लाइब्रेरी (Serialization/Deserialization framework) Rust इकोसिस्टम में डेटा फ़ॉर्मेट के साथ काम करने का डी फैक्टो मानक है। serde_json के साथ मिलकर, यह आपको Rust संरचनाओं को JSON और वापस आसानी से बदलने की अनुमति देता है।

प्रोजेक्ट सेटअप और डिपेंडेंसी इंस्टॉलेशन

शुरू करने के लिए, एक नया Cargo प्रोजेक्ट बनाएँ और Cargo.toml फ़ाइल में आवश्यक डिपेंडेंसी जोड़ें:

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

serde क्रेट के लिए features = ["derive"] फ़्लैग #[derive(Serialize, Deserialize)] मैक्रोज़ को सक्षम करता है, जो स्वचालित रूप से संरचनाओं को सीरियलाइज़ और डिसीरियलाइज़ करने के लिए कोड उत्पन्न करता है।

Rust में JSON पार्सिंग की मूल बातें

JSON स्ट्रिंग को डायनामिक वैल्यू में पार्स करना

JSON पार्स करने का सबसे सरल तरीका serde_json::Value टाइप का उपयोग करना है, जो एक सामान्य JSON वैल्यू को दर्शाता है:

use serde_json::Value;

fn main() {    let data = r#"    {        "name": "Alexey",        "age": 30,        "is_student": false,        "hobbies": ["reading", "programming", "cycling"]    }"#;

    let parsed: Value = serde_json::from_str(data).expect("JSON parsing error");        println!("Name: {}", parsed["name"]);    println!("Age: {}", parsed["age"]);    println!("Student: {}", parsed["is_student"]);    println!("First hobby: {}", parsed["hobbies"][0]);}

Value टाइप एक एनम है जिसमें Null, Bool, Number, String, Array, या Object हो सकता है। यह त्वरित प्रोटोटाइप के लिए सुविधाजनक है, लेकिन प्रोडक्शन कोड के लिए मजबूत टाइप वाली संरचनाओं का उपयोग करना बेहतर है।

JSON को मजबूत टाइप वाली संरचनाओं में पार्स करना

सुरक्षित डेटा हैंडलिंग के लिए, JSON स्कीमा से मेल खाने वाली एक संरचना परिभाषित करें और serde मैक्रोज़ का उपयोग करें:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u32,    is_student: bool,    hobbies: Vec<String>,}

fn main() {    let json_str = r#"    {        "name": "Maria",        "age": 25,        "is_student": true,        "hobbies": ["drawing", "music"]    }"#;

    let person: Person = serde_json::from_str(json_str)        .expect("Deserialization error");        println!("{:?}", person);    println!("{} is studying: {}", person.name, person.is_student);}

इस दृष्टिकोण का लाभ यह है कि कंपाइलर कंपाइल टाइम पर टाइप्स की जाँच करता है, जिससे गलत फ़ील्ड एक्सेस से संबंधित रनटाइम त्रुटियाँ समाप्त हो जाती हैं।

डेटा को JSON में सीरियलाइज़ करना

संरचनाओं को JSON स्ट्रिंग में बदलना

सीरियलाइज़ेशन serde_json::to_string() फ़ंक्शन का उपयोग करके किया जाता है:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Product {    id: u64,    name: String,    price: f64,    in_stock: bool,}

fn main() {    let product = Product {        id: 42,        name: "Laptop".to_string(),        price: 89999.99,        in_stock: true,    };

    let json_string = serde_json::to_string(&product)        .expect("Serialization error");        println!("JSON: {}", json_string);        // Pretty print with o