Rust में JSON के साथ काम: डेटा पार्सिंग और सीरियलाइज़ेशन

परिचय: Rust डेवलपर के लिए JSON क्यों महत्वपूर्ण है

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

इस लेख में, हम देखेंगे कि मानक क्रेट इकोसिस्टम serde और serde_json का उपयोग करके Rust में JSON के साथ प्रभावी ढंग से कैसे काम किया जाए। आप सीखेंगे कि डेटा संरचनाओं को JSON में और वापस कैसे बदलें, त्रुटियों को कैसे संभालें और डायनामिक डेटा के साथ कैसे काम करें।

मूल बातें: निर्भरताएँ स्थापित करना और जोड़ना

Rust में JSON के साथ काम करने के लिए, शक्तिशाली सीरियलाइज़ेशन फ्रेमवर्क Serde और JSON के लिए इसका कार्यान्वयन — क्रेट serde_json का उपयोग किया जाता है। शुरू करने के लिए, उन्हें अपने Cargo.toml में जोड़ें:

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

फ्लैग features = ["derive"] मैक्रोज़ #[derive(Serialize, Deserialize)] का उपयोग करने की अनुमति देता है, जो कोड को काफी सरल बनाता है।

JSON स्ट्रिंग का बुनियादी पार्सिंग

शुरू करने का सबसे आसान तरीका JSON स्ट्रिंग को सार्वभौमिक प्रकार serde_json::Value में पार्स करना है। यह Python में serde_json::Value या JavaScript में object के समान है:

use serde_json::Value;

fn main() {    let data = r#"        {            "name": "Rust",            "year": 2015,            "features": ["safe", "fast", "concurrent"]        }"#;

    let parsed: Value = serde_json::from_str(data).expect("JSON पार्सिंग में त्रुटि");        println!("नाम: {}", parsed["name"]);    println!("वर्ष: {}", parsed["year"]);    println!("पहली विशेषता: {}", parsed["features"][0]);}

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

संरचनाओं का सीरियलाइज़ेशन और डीसीरियलाइज़ेशन

Serde की मुख्य शक्ति Rust संरचनाओं और JSON के बीच स्वचालित रूपांतरण है। आइए एक उदाहरण देखें:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]struct User {    id: u32,    name: String,    email: String,    active: bool,}

fn main() {    // डीसीरियलाइज़ेशन (JSON -> Rust)    let json_str = r#"{"id":1,"name":"एलेक्सी","email":"alex@example.com","active":true}"#;    let user: User = serde_json::from_str(json_str).unwrap();    println!("उपयोगकर्ता: {:?}", user);

    // सीरियलाइज़ेशन (Rust -> JSON)    let new_user = User {        id: 2,        name: String::from("मारिया"),        email: String::from("maria@example.com"),        active: false,    };    let json_output = serde_json::to_string_pretty(&new_user).unwrap();    println!("JSON:{}", json_output);}

to_string_pretty पर ध्यान दें — यह पठनीयता के लिए इंडेंटेशन के साथ JSON को फॉर्मेट करता है। प्रोडक्शन के लिए to_string (अतिरिक्त स्थानों के बिना) का उपयोग करें।

नेस्टेड संरचनाओं के साथ काम करना

JSON में अक्सर नेस्टेड ऑब्जेक्ट और ऐरे होते हैं। Serde आसानी से इससे निपटता है:

#[derive(Serialize, Deserialize)]struct Project {    name: String,    languages: Vec<String>,    contributors: Vec<Contributor>,}

#[derive(Serialize, Deserialize)]struct Contributor {    username: String,    contributions: u32,}

fn main() {    let project_json = r#"    {        "name": "Serde",        "languages": ["Rust", "Python", "C++"],        "contributors": [