Rust में XML पार्सिंग और सीरियलाइज़ेशन: roxmltree…

Rust में XML के साथ काम: लाइब्रेरीज़ और व्यावहारिक उदाहरण

Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जिसका उपयोग हाई-लोड वेब सर्विसेज़, कमांड-लाइन टूल्स और एम्बेडेड सिस्टम बनाने के लिए तेज़ी से बढ़ रहा है। डेटा के साथ काम करते समय अक्सर XML दस्तावेज़ों को प्रोसेस करने की आवश्यकता होती है। Python के विपरीत, जहां स्टैंडर्ड लाइब्रेरी xml.etree.ElementTree अधिकांश कार्यों को कवर करती है, Rust इकोसिस्टम में अलग-अलग दृष्टिकोणों के साथ कई विशेष क्रेट (crates) उपलब्ध हैं। इस लेख में हम Rust में XML के साथ काम करने के लिए तीन सबसे लोकप्रिय टूल्स पर चर्चा करेंगे: roxmltree, quick-xml और serde-xml-rs।

1. roxmltree — तेज़ और सुरक्षित रीड-ओनली पार्सर

roxmltree एक क्रेट है जो केवल XML पढ़ने के लिए डिज़ाइन किया गया है। यह दस्तावेज़ों को बदलने या बनाने का समर्थन नहीं करता, लेकिन नेमस्पेस (namespaces) के पूर्ण समर्थन के साथ एक बहुत तेज़ और विश्वसनीय पार्सर प्रदान करता है। इसका मुख्य लाभ जीरो-कॉपी (zero-copy) के साथ काम करना है, जो मेमोरी आवंटन को कम करता है।

// cargo add roxmltree
use roxmltree::Document;

fn main() -> Result<(), roxmltree::Error> {
    let xml = r#"
    <root>
        <item id="1">पहला तत्व</item>
        <item id="2">दूसरा तत्व</item>
    </root>"#;

    let doc = Document::parse(xml)?;

    // रूट एलिमेंट प्राप्त करें
    let root = doc.root_element();
    println!("रूट एलिमेंट: {}", root.tag_name().name());

    // सभी चाइल्ड <item> एलिमेंट खोजें
    for item in root.children().filter(|n| n.has_tag_name("item")) {
        let id = item.attribute("id").unwrap_or("unknown");
        let text = item.text().unwrap_or("");
        println!("ID: {}, टेक्स्ट: {}", id, text);
    }

    Ok(())
}

कब उपयोग करें: यदि आपको केवल XML फ़ाइलें (कॉन्फ़िगरेशन, API रिस्पॉन्स, RSS फ़ीड) पढ़नी हैं और अधिकतम प्रदर्शन चाहिए। roxmltree एक बार पार्सिंग के लिए आदर्श है।

2. quick-xml — पढ़ने और लिखने के साथ सार्वभौमिक पार्सर

quick-xml Rust में XML के साथ काम करने के लिए सबसे लोकप्रिय क्रेट है। यह पार्सिंग (इवेंट-आधारित और DOM-जैसी) और सीरियलाइज़ेशन (लेखन) दोनों का समर्थन करता है। यह स्ट्रीम (Reader) और पूर्ण स्ट्रिंग दोनों के साथ काम करता है। यह एट्रीब्यूट्स, CDATA, कमेंट्स और एस्केप सीक्वेंस को सपोर्ट करता है।

// cargo add quick-xml
use quick_xml::Reader;
use quick_xml::events::Event;

fn main() -> Result<(), quick_xml::Error> {
    let xml = r#"<library>
    <book genre="rust">Rust प्रोग्रामिंग</book>
    <book genre="python">शुरुआती के लिए Python</book>
</library>"#;

    let mut reader = Reader::from_str(xml);
    reader.trim_text(true);
    let mut txt = String::new();
    let mut current_genre = String::new();

    loop {
        match reader.read_event_into(&mut txt) {
            Ok(Event::Start(ref e)) => {
                if e.name().as_ref() == b"book" {
                    // genre एट्रीब्यूट प्राप्त करें
                    if let Some(attr) = e.attributes().flatten().find(|a| a.key.as_ref() == b"genre") {
                        current_genre = String::from_utf8_lossy(&attr.value).to_string();
                    }
                }
            }
            Ok(Event::Text(ref e)) => {
                let text = e.unescape()?;
                println!("शैली: {}, नाम: {}", current_genre, text);
            }
            Ok(Event::Eof) => break,
            Err(e) => panic!("त्रुटि: {:?}", e),
            _ => {}
        }
        txt.clear();
    }
    Ok(())
}

कब उपयोग करें: यदि आपको लचीलापन चाहिए — बड़ी फ़ाइलों को स्ट्रीम करके पढ़ना, नए XML दस्तावेज़ बनाना या मौजूदा को संशोधित करना। quick-xml अधिकांश परियोजनाओं के लिए डिफ़ॉल्ट विकल्प है।