Rust में ऑब्जेक्ट सीरियलाइज़ेशन: Serde और अन्य टूल्स

Rust में ऑब्जेक्ट सीरियलाइज़ेशन: लाइब्रेरी और टूल्स की पूरी जानकारी

सीरियलाइज़ेशन सॉफ्टवेयर डेवलपमेंट की एक बुनियादी प्रक्रिया है। यह जटिल डेटा स्ट्रक्चर (ऑब्जेक्ट, स्ट्रक्चर, एनुम) को एक ऐसे फॉर्मेट में बदलता है जिसे डिस्क पर सेव किया जा सके या नेटवर्क पर भेजा जा सके। इसका उल्टा प्रोसेस — डीसीरियलाइज़ेशन — मूल ऑब्जेक्ट को वापस रिस्टोर करता है। Rust भाषा में इस काम के लिए एक पूरी इकोसिस्टम मौजूद है, जिसमें सबसे अहम भूमिका Serde (Serialization/Deserialization) लाइब्रेरी की है।

इस आर्टिकल में हम विस्तार से जानेंगे कि Rust में सीरियलाइज़ेशन कैसे काम करता है, इसके लिए कौन-कौन सी लाइब्रेरी मौजूद हैं, और उन्हें प्रैक्टिकल तरीके से कैसे इस्तेमाल करें।

Serde क्यों?

Serde सिर्फ एक लाइब्रेरी नहीं, बल्कि सीरियलाइज़ेशन और डीसीरियलाइज़ेशन का एक पूरा फ्रेमवर्क है। इसकी सबसे बड़ी खासियत है इसे दो भागों में बांटना:

• Serde Data Model — कोर, जो यह तय करता है कि Rust के डेटा टाइप्स को इंटरमीडिएट रिप्रेजेंटेशन में कैसे बदला जाए।
• फॉर्मेट एडॉप्टर — अलग-अलग क्रेट्स जो विशिष्ट फॉर्मेट्स (JSON, YAML, TOML, Bincode, MessagePack आदि) के साथ काम करते हैं।

इस तरीके से आप एक ही कोड का इस्तेमाल करके अलग-अलग फॉर्मेट्स के साथ काम कर सकते हैं, बस Cargo.toml में एक लाइन बदलनी होती है।

कनेक्शन और बेसिक सेटअप

शुरू करने के लिए Cargo.toml में ये डिपेंडेंसीज़ जोड़ें:

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

सबसे खास बात है #[derive(Serialize, Deserialize)] एट्रीब्यूट का इस्तेमाल। यह आपके स्ट्रक्चर को कन्वर्ट करने के लिए ऑटोमैटिक कोड जनरेट करता है:

use serde::{Serialize, Deserialize};

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

fn main() {
    let user = User {
        id: 42,
        name: "अलेक्से".to_string(),
        email: "alex@example.com".to_string(),
        is_active: true,
    };

    // JSON में सीरियलाइज़ करें
    let json = serde_json::to_string_pretty(&user).unwrap();
    println!("JSON:\n{}", json);

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

अलग-अलग फॉर्मेट्स के साथ काम करना

Serde दर्जनों फॉर्मेट्स को सपोर्ट करता है। आइए सबसे लोकप्रिय फॉर्मेट्स पर नज़र डालें:

JSON (serde_json)

वेब API के लिए सबसे आम फॉर्मेट। मानव-पठनीय, लेकिन ज्यादा जगह लेता है।

// स्ट्रिंग में सीरियलाइज़ करें
let json_str = serde_json::to_string(&data)?;

// स्ट्रीम (फ़ाइल) में सीरियलाइज़ करें
let file = std::fs::File::create("data.json")?;
let writer = std::io::BufWriter::new(file);
serde_json::to_writer(writer, &data)?;

// फ़ाइल से पढ़ें
let file = std::fs::File::open("data.json")?;
let reader = std::io::BufReader::new(file);
let data: MyStruct = serde_json::from_reader(reader)?;

Bincode (bincode)

बाइनरी फॉर्मेट — कॉम्पैक्ट और तेज़। Rust सर्विसेज के बीच इंटरनल स्टोरेज या ट्रांसमिशन के लिए आदर्श।

// Cargo.toml: bincode = "1.3"

let encoded: Vec<u8> = bincode::serialize(&data)?;
let decoded: MyStruct = bincode::deserialize(&encoded)?;

YAML और TOML (serde_yaml, toml)

कॉन्फ़िगरेशन फ़ाइलों के लिए इस्तेमाल होते हैं। मानव-पठनीय, कमेंट्स सपोर्ट करते हैं (YAML)।

// YAML
let yaml = serde_yaml::to_string(&data)?;
let data: MyStruct = serde_yaml::from_str(&yaml)?;

// TOML (Rust इकोसिस्टम में लोकप्रिय)
let toml = toml::to_string(&data)?;
let data: MyStruct = toml::from_str(&toml)?;

एडवांस्ड फीचर्स: Serde एट्रीब्यूट्स

Serde सीरियलाइज़ेशन को बारीकी से कस्टमाइज़ करने के लिए शक्तिशाली एट्रीब्यूट्स प्रदान करता है:

#[derive(Serialize, Deserialize)]
struct Config {
    #[serde(rename = "server_host")]
    host: String,

    #[serde(defau