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

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

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

डायनामिक भाषाओं के विपरीत, Rust को प्रकारों के स्पष्ट विवरण की आवश्यकता होती है, जो पहली नज़र में जटिल लग सकता है। हालाँकि, व्यवहार में यह अविश्वसनीय विश्वसनीयता प्रदान करता है: आपको रनटाइम के दौरान कभी भी अप्रत्याशित null या गलत प्रकार वाला फ़ील्ड नहीं मिलेगा। इस लेख में, हम विशिष्ट उदाहरणों के साथ JSON पार्सिंग (डीसीरियलाइज़ेशन) और सीरियलाइज़ेशन को समझेंगे, जिन्हें आप वास्तविक प्रोजेक्ट्स में तुरंत लागू कर सकते हैं।

1. प्रोजेक्ट सेटअप और निर्भरताएँ स्थापित करना

कोड लिखने से पहले, Cargo.toml में आवश्यक क्रेट्स जोड़ें:

[dependencies]\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"

derive फ़्लैग के साथ serde क्रेट हमारी संरचनाओं के लिए सीरियलाइज़ेशन और डीसीरियलाइज़ेशन कोड को स्वचालित रूप से उत्पन्न करने की अनुमति देता है। serde_json सीधे JSON में/से रूपांतरण के लिए जिम्मेदार है।

main.rs में सभी आवश्यक चीज़ें आयात करें:

use serde::{Deserialize, Serialize};\nuse serde_json::Result;

2. सीरियलाइज़ेशन: Rust संरचना को JSON में बदलना

सीरियलाइज़ेशन एक Rust ऑब्जेक्ट को JSON स्ट्रिंग में बदलने की प्रक्रिया है। आइए उपयोगकर्ता डेटा के साथ एक क्लासिक उदाहरण देखें।

संरचना घोषित करना

अपनी संरचना में #[derive(Serialize, Deserialize)] एनोटेशन जोड़ें:

#[derive(Debug, Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n    is_active: bool,\n    tags: Vec<String>,\n}

इंस्टेंस बनाना और सीरियलाइज़ करना

अब एक ऑब्जेक्ट बनाएँ और इसे JSON में बदलें:

fn main() -> Result<()> {\n    let user = User {\n        id: 42,\n        name: "एलेक्सी".to_string(),\n        email: "alex@example.com".to_string(),\n        is_active: true,\n        tags: vec!["rust".to_string(), "backend".to_string()],\n    };\n\n    // JSON स्ट्रिंग में सीरियलाइज़ेशन\n    let json_string = serde_json::to_string(&user)?;\n    println!("{}", json_string);\n\n    // सुंदर (pretty) सीरियलाइज़ेशन\n    let pretty_json = serde_json::to_string_pretty(&user)?;\n    println!("{}", pretty_json);\n\n    Ok(())\n}

निष्पादन का परिणाम:

{"id":42,"name":"एलेक्सी","email":"alex@example.com","is_active":true,"tags":["rust","backend"]}\n\n{\n  "id": 42,\n  "name": "एलेक्सी",\n  "email": "alex@example.com",\n  "is_active": true,\n  "tags": [\n    "rust",\n    "backend"\n  ]\n}

ध्यान दें: to_string_pretty इंडेंटेशन और लाइन ब्रेक जोड़ता है - कॉन्फ़िगरेशन फ़ाइलों या लॉग के लिए आदर्श।

3. पार्सिंग (डीसीरियलाइज़ेशन): JSON से Rust संरचना में

डीसीरियलाइज़ेशन उलटी प्रक्रिया है: हम एक JSON स्ट्रिंग प्राप्त करते हैं और इसे एक टाइप की गई Rust संरचना में बदलते हैं।

स्ट्रिंग से पार्सिंग

fn parse_user_from_json(json_str: &str) -> Result<User> {\n    let user: User = serde_json::from_str(json_str)?;\n    Ok(user)\n}\n\nfn main() -> Result<()> {\n    let data = r#"\n        {\n            "id": 101,\n            "name": "मारिया",\n            "email": "maria@example.com",\n            "is_active": false,\n            "tags": ["python", "data-science"]\n        }\n    "#;\n\n    let user = parse_user_from_json(data)?;\n    println!("उपयोगकर्ता: {:?}", user);\n    println!("नाम: {}", user.name);\n    println!("सक्रिय: {}", user.is_active);\n\n    Ok(())\n}

यदि JSON संरचना से मेल नहीं खाता है (उदा.