Serde Rust: तरीके, उदाहरण, इंस्टॉलेशन

Serde क्या है और इसकी आवश्यकता क्यों है

Serde (Serialization/Deserialization का संक्षिप्त रूप) Rust भाषा में डेटा संरचनाओं को सीरियलाइज़ और डीसीरियलाइज़ करने के लिए एक फ्रेमवर्क है। यह Rust इकोसिस्टम में डेटा फॉर्मेट के साथ काम करने का डी-फैक्टो मानक है। यह लाइब्रेरी जटिल Rust प्रकारों (स्ट्रक्चर, एनुम, वेक्टर, हैश टेबल) को विभिन्न टेक्स्ट और बाइनरी फॉर्मेट (JSON, YAML, TOML, BSON, MessagePack, CBOR, और कई अन्य) में और वापस बदलने की अनुमति देती है।

Serde का मुख्य दर्शन है बिना किसी समझौते के प्रदर्शन। यह कंपाइल टाइम पर अत्यधिक अनुकूलित कोड उत्पन्न करने के लिए Rust की शक्तिशाली मैक्रो प्रणाली का उपयोग करता है, जो इसे सभी प्रोग्रामिंग भाषाओं में सबसे तेज़ सीरियलाइज़ेशन लाइब्रेरी में से एक बनाता है। Serde किसी विशिष्ट फॉर्मेट से बंधा नहीं है: यह अमूर्त ट्रेट्स Serialize और Deserialize प्रदान करता है, और विशिष्ट फॉर्मेट अलग-अलग क्रेट्स (जैसे serde_json, serde_yaml) में लागू किए जाते हैं।

Serde की आवश्यकता क्यों है?

स्टेट सेव करना: कॉन्फ़िगरेशन, गेम सेव, कैश को डिस्क पर लिखना
नेटवर्क प्रोटोकॉल: क्लाइंट और सर्वर के बीच डेटा एक्सचेंज (REST API, WebSocket)
कॉन्फ़िगरेशन फ़ाइलें: JSON/YAML/TOML से सेटिंग्स पढ़ना
डेटाबेस: Redis, MongoDB और अन्य DB में स्टोर करने के लिए रिकॉर्ड सीरियलाइज़ करना
इंटर-प्रोसेस कम्युनिकेशन: पाइप या सॉकेट के माध्यम से प्रक्रियाओं के बीच डेटा ट्रांसफर

इंस्टॉलेशन

Serde को Rust में बिल्ट-इन पैकेज मैनेजर Cargo के माध्यम से इंस्टॉल किया जाता है। शुरू करने के लिए, Cargo.toml फ़ाइल में डिपेंडेंसी जोड़ें:

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

डिपेंडेंसी की व्याख्या:

serde — लाइब्रेरी का कोर जिसमें Serialize और Deserialize ट्रेट्स हैं। फ्लैग features = ["derive"] मैक्रो #[derive(Serialize, Deserialize)] के सपोर्ट को सक्षम करता है।
serde_json — JSON फॉर्मेट का इम्प्लीमेंटेशन। इसी तरह serde_yaml, serde_toml, bincode और अन्य को जोड़ा जा सकता है।

यदि आप Rust 2021 edition या उससे नए वर्जन का उपयोग कर रहे हैं, तो बस ये लाइनें जोड़ना पर्याप्त है। किसी विशिष्ट वर्जन को इंस्टॉल करने के लिए, नंबर निर्दिष्ट करें, जैसे serde_json = "1.0.128"।

त्वरित शुरुआत: पहला उदाहरण

एक सरल स्ट्रक्चर बनाएं और इसे JSON में सीरियलाइज़ करें, फिर वापस डीसीरियलाइज़ करें:

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

// सीरियलाइज़ेशन/डीसीरियलाइज़ेशन कोड के ऑटोमैटिक जनरेशन वाला स्ट्रक्चर
#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
    active: bool,
}

fn main() {
    // स्ट्रक्चर का इंस्टेंस बनाएं
    let user = User {
        id: 42,
        name: "अलीसा".to_string(),
        email: "alice@example.com".to_string(),
        active: true,
    };

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

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

    // जांचें कि डेटा खो नहीं गया है
    assert_eq!(user.id, deserialized_user.id);
    assert_eq!(user.name, deserialized_user.name);
}

प्रोग्राम का आउटपुट:

सीरियलाइज़ किया गया JSON: {"id":42,"name":"अलीसा","email":"alice@example.com","active":true}
डीसीरियलाइज़ किया गया स्ट्रक्चर: User { id: 42, name: "अलीसा", email: "alice@example.com", active: true }