Go (Golang) में XML के साथ कार्य: encoding/xml पैकेज और विकल्प

Go भाषा में XML प्रसंस्करण का परिचय

Go (Golang) भाषा मानक पैकेज encoding/xml के माध्यम से XML के साथ काम करने का एक शक्तिशाली और सुरुचिपूर्ण तरीका प्रदान करती है। यह पैकेज स्ट्रक्चर एनोटेशन (struct tags) का उपयोग करके XML दस्तावेज़ों को पढ़ने (पार्सिंग) और लिखने (सीरियलाइज़ेशन) के लिए एक सरल इंटरफ़ेस लागू करता है। कई अन्य भाषाओं के विपरीत, Go को अलग DOM या SAX पार्सर बनाने की आवश्यकता नहीं होती है — बस डेटा संरचना का वर्णन करें, और पैकेज स्वयं XML टैग को फ़ील्ड से मैप कर देगा।

इस लेख में, हम encoding/xml पैकेज की मुख्य क्षमताओं का विस्तार से विश्लेषण करेंगे, बुनियादी पार्सिंग से शुरू करके उन्नत तकनीकों तक: विशेषताओं, नेमस्पेस, बड़ी फ़ाइलों के स्ट्रीमिंग रीडिंग और XML जनरेशन का प्रबंधन। हम लोकप्रिय तृतीय-पक्ष लाइब्रेरीज़ पर भी विचार करेंगे जो विशिष्ट परिदृश्यों में उपयोगी हो सकती हैं।

मूल बातें: Go स्ट्रक्चर में XML पार्सिंग

Go में XML के साथ काम करने का सबसे सामान्य तरीका XML डेटा को स्ट्रक्चर इंस्टेंस में डीसीरियलाइज़ (unmarshal) करना है। इसके लिए फ़ंक्शन xml.Unmarshal() का उपयोग किया जाता है। मुख्य विशेषता स्ट्रक्चर फ़ील्ड घोषणा में xml:"..." टैग का उपयोग है।

सरल उदाहरण: RSS फ़ीड पार्सिंग

package main

import (    "encoding/xml"    "fmt")

// RSS तत्व के लिए स्ट्रक्चरtype RSS struct {    XMLName xml.Name `xml:"rss"`    Channel Channel  `xml:"channel"`}

type Channel struct {    Title       string    `xml:"title"`    Description string    `xml:"description"`    Items       []Item    `xml:"item"`}

type Item struct {    Title       string `xml:"title"`    Link        string `xml:"link"`    Description string `xml:"description"`}

func main() {    data := `<?xml version="1.0" encoding="UTF-8"?>    <rss version="2.0">        <channel>            <title>Example Feed</title>            <description>A sample RSS feed</description>            <item>                <title>First Post</title>                <link>https://example.com/1</link>                <description>This is the first post.</description>            </item>        </channel>    </rss>`

    var rss RSS    err := xml.Unmarshal([]byte(data), &rss)    if err != nil {        panic(err)    }

    fmt.Printf("चैनल: %s", rss.Channel.Title)    fmt.Printf("विवरण: %s", rss.Channel.Description)    for _, item := range rss.Channel.Items {        fmt.Printf("- %s (%s)", item.Title, item.Link)    }}

इस उदाहरण में, टैग xml:"rss" स्ट्रक्चर को रूट एलिमेंट से जोड़ता है, और xml:"channel", xml:"item" नेस्टेड एलिमेंट से। XMLName फ़ील्ड वैकल्पिक है, लेकिन यह रूट एलिमेंट का नाम प्राप्त करने की अनुमति देता है।

XML विशेषताओं के साथ कार्य

XML विशेषताओं को टैग में विशेष सिंटैक्स के माध्यम से संभाला जाता है: xml:"टैग_नाम,attr"। यदि विशेषता सीधे रूट एलिमेंट में है, तो xml:",attr" का उपयोग किया जाता है।

type Person struct {    XMLName xml.Name `xml:"person"`    ID      int      `xml:"id,attr"`    Name    string   `xml:"name"`    Age     int      `xml:"age,attr"`}

func main() {    xmlData := `<person id="123" age="30"><name>Alice</name></person>`    var p Person    xml.Unmarshal([]byte(xmlData), &p)    fmt.Printf("ID: %d, नाम: %s, आयु: %d", p.ID, p.Name, p.Age)    // आउटपुट: ID: 123, नाम: Alice, आयु: 30}

XML जनरेशन (सीरियलाइज़ेशन)

स्ट्रक्चर से XML बनाने के लिए फ़ंक्शन xml.Marshal() या फ़ॉर्मेटेड आउटपुट के लिए xml.MarshalIndent() का उपयोग किया जाता है। पैकेज सही एलिमेंट नाम और विशेषताएँ उत्पन्न करने के लिए स्वचालित रूप से स्ट्रक्चर टैग का उपयोग करता है।

type Book struct {    XMLName xml.Name `xml:"book"`    Title   string