Rust में ऑब्जेक्ट सीरियलाइज़ेशन: serde, bincode, JSON |…

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

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

serde क्या है और यह डी-फैक्टो मानक क्यों है?

serde Rust में डेटा संरचनाओं के सीरियलाइज़ेशन और डीसीरियलाइज़ेशन के लिए एक फ्रेमवर्क है। यह किसी विशिष्ट फ़ॉर्मेट से बंधा नहीं है - आप JSON, Bincode, YAML, TOML, MessagePack, CBOR और कई अन्य का उपयोग कर सकते हैं। मुख्य विचार: आप अपनी संरचना का वर्णन एक बार करते हैं, और serde Serialize और Deserialize ट्रेट्स की प्रणाली के माध्यम से किसी भी फ़ॉर्मेट के साथ काम करने के लिए स्वचालित रूप से कोड उत्पन्न करता है।

serde के लाभ:

अधिकतम प्रदर्शन - कोड संकलन चरण में उत्पन्न होता है (zero-cost abstraction)
टाइप सुरक्षा - फ़ॉर्मेट बेमेल त्रुटियाँ संकलन चरण में पकड़ी जाती हैं
जटिल संरचनाओं का समर्थन: enum, वेक्टर, हैश-मैप, नेस्टेड ऑब्जेक्ट
एट्रीब्यूट्स के माध्यम से अनुकूलन की संभावना

स्थापना और बुनियादी सेटअप

Cargo.toml में निम्नलिखित निर्भरताएँ जोड़ें:

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

मुख्य बिंदु serde के लिए feature "derive" है। इसके बिना आपको मैन्युअल रूप से Serialize और Deserialize ट्रेट्स को लागू करना होगा।

सरल उदाहरण: JSON में सीरियलाइज़ेशन

JSON वेब एप्लिकेशन और API के लिए सबसे लोकप्रिय फ़ॉर्मेट है। आइए एक बुनियादी उदाहरण देखें:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct User {    id: u32,    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(&user).unwrap();    println!("JSON: {}", json);

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

आउटपुट:

JSON: {"id":42,"name":"एलेक्सी","email":"alex@example.com","is_active":true}डीसीरियलाइज़ किया गया: User { id: 42, name: "एलेक्सी", email: "alex@example.com", is_active: true }

bincode के साथ बाइनरी सीरियलाइज़ेशन

उच्च-प्रदर्शन अनुप्रयोगों (गेम, रियल-टाइम सिस्टम, डेटाबेस) के लिए अक्सर कॉम्पैक्ट बाइनरी फ़ॉर्मेट की आवश्यकता होती है। bincode सबसे अच्छे विकल्पों में से एक है:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct GameState {    level: u16,    health: f32,    inventory: Vec<String>,    checkpoint: (f64, f64),}

fn main() {    let state = GameState {        level: 5,        health: 87.5,        inventory: vec!["तलवार".into(), "औषधि".into()],        checkpoint: (120.5, -34.8),    };

    // बाइनरी फ़ॉर्मेट में सीरियलाइज़ेशन    let binary = bincode::serialize(&state).unwrap();    println!("बाइनरी आकार: {} बाइट", binary.len());

    // डीसीरियलाइज़ेशन    let restored: GameState = bincode::deserialize(&binary).unwrap();    println!("पुनर्स्थापित: {:?}", restored);}

Bincode JSON की तुलना में डेटा आकार और प्रसंस्करण गति में लाभ देता है। उदाहरण के लिए, 4 फ़ील्ड वाली संरचना JSON में 100+ के मुकाबले लगभग 40 बाइट लेगी।