Rust में JSON प्रसंस्करण: शैक्षिक साइट के लिए serde_json लाइब्रेरी

Rust में JSON प्रसंस्करण: serde_json के साथ पूर्ण मार्गदर्शिका

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

स्थापना और कॉन्फ़िगरेशन

शुरू करने के लिए, Cargo.toml फ़ाइल में निर्भरताएँ जोड़ें:

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

serde लाइब्रेरी मैक्रोज़ #[derive(Serialize, Deserialize)] प्रदान करती है, और serde_json डेटा को JSON में और वापस बदलने के लिए जिम्मेदार है।

बुनियादी सीरियलाइज़ेशन और डीसीरियलाइज़ेशन

एक सरल उदाहरण देखें: एक User संरचना बनाएँ और इसे JSON में और वापस बदलना सीखें।

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

#[derive(Debug, Serialize, Deserialize)]struct User {    name: String,    age: u8,    email: String,}

fn main() {    // संरचना का एक उदाहरण बनाएँ    let user = User {        name: "Алексей".to_string(),        age: 30,        email: "alex@example.com".to_string(),    };

    // JSON स्ट्रिंग में सीरियलाइज़ेशन    let json_string = serde_json::to_string(&user).unwrap();    println!("JSON: {}", json_string);

    // JSON से वापस संरचना में डीसीरियलाइज़ेशन    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();    println!("डीसीरियलाइज़ किया गया: {:?}", deserialized_user);}

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

JSON: {"name":"Алексей","age":30,"email":"alex@example.com"}डीसीरियलाइज़ किया गया: User { name: "Алексей", age: 30, email: "alex@example.com" }

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

JSON में अक्सर नेस्टेड ऑब्जेक्ट और ऐरे होते हैं। Rust ऐसी संरचनाओं को आसानी से मॉडल करने की अनुमति देता है:

#[derive(Debug, Serialize, Deserialize)]struct Address {    city: String,    street: String,    house: u16,}

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u8,    address: Address,    hobbies: Vec<String>,}

fn main() {    let person = Person {        name: "Мария".to_string(),        age: 25,        address: Address {            city: "Москва".to_string(),            street: "Тверская".to_string(),            house: 10,        },        hobbies: vec!["чтение".to_string(), "спорт".to_string()],    };

    // इंडेंटेशन के साथ सुंदर JSON आउटपुट    let pretty_json = serde_json::to_string_pretty(&person).unwrap();    println!("{}", pretty_json);}

आउटपुट:

{  "name": "Мария",  "age": 25,  "address": {    "city": "Москва",    "street": "Тверская",    "house": 10  },  "hobbies": [    "чтение",    "спорт"  ]}

त्रुटि प्रबंधन और वैकल्पिक फ़ील्ड

वास्तविक परियोजनाओं में, डेटा अधूरा हो सकता है। Rust ऐसी स्थितियों को संभालने के लिए सुरुचिपूर्ण तरीके प्रदान करता है:

• Option<T> — वैकल्पिक फ़ील्ड के लिए
• Result<T, E> — पार्सिंग त्रुटियों को संभालने के लिए
• Serde विशेषताएँ — सीरियलाइज़ेशन व्यवहार को कॉन्फ़िगर करने के लिए

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

#[derive(Debug, Serialize, Deserialize)]struct Product {    name: String,    price: f64,    #[serde(default)] // फ़ील्ड अनुपस्थित होने पर डिफ़ॉल्ट मान    description: Option<String>,    #[serde(skip_serializing_if = "Option::is_none")] // None होने पर छोड़ें    discount: