Go में XML के साथ काम: encoding/xml, लाइब्रेरी और उदाहरण

Go (Golang) में XML के साथ काम: उदाहरण सहित पूरी गाइड

Go (Golang) encoding/xml पैकेज के ज़रिए XML के साथ काम करने की बिल्ट-इन सुविधा देता है। यह पैकेज XML डेटा को पार्स (पढ़ने), जनरेट (लिखने) और सीरियलाइज़ करने के लिए शक्तिशाली टूल्स प्रदान करता है। JSON के विपरीत, XML को अधिक सख्त संरचना और नेमस्पेस (namespaces) के सपोर्ट की ज़रूरत होती है, जो encoding/xml को विशेष रूप से लचीला बनाता है।

इस लेख में हम विस्तार से जानेंगे कि Go में XML के साथ कैसे काम करें: बेसिक अनमार्शलिंग (XML को Go स्ट्रक्चर में बदलना) से लेकर एट्रीब्यूट और नेमस्पेस वाले जटिल XML डॉक्यूमेंट बनाने तक।

बुनियादी बातें: स्ट्रक्चर और XML टैग

XML एलिमेंट्स को Go स्ट्रक्चर के फील्ड से मैप करने के लिए विशेष xml टैग का उपयोग किया जाता है। ये टैग एलिमेंट का नाम, एट्रीब्यूट और सीरियलाइज़ेशन के दौरान व्यवहार निर्धारित करते हैं।

type Person struct {
    XMLName   xml.Name `xml:"person"`
    ID        int      `xml:"id,attr"`
    Name      string   `xml:"name"`
    Age       int      `xml:"age"`
    Email     string   `xml:"email,omitempty"`
    Addresses []Address `xml:"address"`
}

type Address struct {
    City    string `xml:"city"`
    Street  string `xml:"street"`
    ZipCode string `xml:"zip"`
}

• xml:"person" — रूट एलिमेंट का नाम।
• xml:"id,attr" — फील्ड एलिमेंट का एट्रीब्यूट बन जाता है।
• xml:"email,omitempty" — अगर फील्ड खाली है तो इसे छोड़ दिया जाता है।
• xml:"address" — ऐरे को कई नेस्टेड एलिमेंट के रूप में सीरियलाइज़ किया जाएगा।

XML पार्स करना: अनमार्शलिंग (Unmarshal)

xml.Unmarshal फंक्शन XML बाइट्स को Go स्ट्रक्चर में बदलता है। आइए अपने Person टाइप के साथ एक उदाहरण देखें:

package main

import (
    "encoding/xml"
    "fmt"
)

func main() {
    xmlData := `<person id="123">
    <name>राहुल शर्मा</name>
    <age>30</age>
    <email>rahul@example.com</email>
    <address>
        <city>मुंबई</city>
        <street>मरीन ड्राइव, 1</street>
        <zip>400001</zip>
    </address>
</person>`

    var p Person
    err := xml.Unmarshal([]byte(xmlData), &p)
    if err != nil {
        fmt.Printf("पार्सिंग में त्रुटि: %v\n", err)
        return
    }

    fmt.Printf("ID: %d\n", p.ID)
    fmt.Printf("नाम: %s\n", p.Name)
    fmt.Printf("उम्र: %d\n", p.Age)
    fmt.Printf("शहर: %s\n", p.Addresses[0].City)
}

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

ID: 123
नाम: राहुल शर्मा
उम्र: 30
शहर: मुंबई

XML जनरेट करना: मार्शलिंग (Marshal)

स्ट्रक्चर से XML बनाने के लिए xml.Marshal या xml.MarshalIndent (इंडेंटेशन के साथ) का उपयोग किया जाता है।

func main() {
    p := Person{
        ID:   456,
        Name: "प्रिया सिंह",
        Age:  25,
        Email: "priya@example.com",
        Addresses: []Address{
            {City: "दिल्ली", Street: "चांदनी चौक, 10", ZipCode: "110006"},
        },
    }

    output, err := xml.MarshalIndent(p, "", "  ")
    if err != nil {
        fmt.Printf("सीरियलाइज़ेशन में त्रुटि: %v\n", err)
        return
    }

    fmt.Println(string(output))
}

परिणाम:

<person id="456">
  <name>प्रिया सिंह</name>
  <age>25</age>
  <email>priya@example.com</email>
  <address>
    <city>दिल्ली</city>
    <street>चांदनी चौक, 10</street>
    <zip>110006</zip>
  </address>
</person>

नेमस्पेस (Namespaces) के साथ काम करना

XML नेमस्पेस को XMLName फील्ड और xmlns एट्रीब्यूट के ज़रिए हैंडल किया जाता है।

type Document struct {
    XMLName xml.Name `xml:"doc"`
    Title   string   `xml:"title"`
    Content string   `xml:"content"`
    Lang    string   `xml:"xml:lang,attr"`
}