How to parse XML data in Go

解析XML数据在Go中非常简单，只需使用内置的encoding/xml包即可。1. 定义带有xml标签的结构体来映射XML元素和属性，如xml:"name"对应子元素，xml:"contact>email"处理嵌套，xml:"id,attr"读取属性；2. 使用xml.Unmarshal将XML字符串解析为结构体；3. 对于文件，使用os.Open打开后通过xml.NewDecoder解码，适合大文件流式处理；4. 处理重复元素时，在结构体中使用切片字段，如[]Person；5. 注意元素名大小写敏感、命名空间处理、可选字段及未知元素的捕获。正确建模结构体后，Go能高效完成XML解析，且推荐小数据用Unmarshal、大数据用Decoder。

Parsing XML data in Go is straightforward thanks to the built-in encoding/xml package. Whether you're reading from a file, a string, or an HTTP response, Go provides clean ways to unmarshal XML into structs. Here's how to do it effectively.

Define Structs with XML Tags

To parse XML, you first define Go structs that mirror the structure of the XML. Use struct tags with the xml key to map XML elements and attributes to struct fields.

type Person struct {
    XMLName xml.Name `xml:"person"`
    Name    string   `xml:"name"`
    Age     int      `xml:"age"`
    Email   string   `xml:"contact>email"` // Nested element
    Phone   string   `xml:"contact>phone"`
    ID      string   `xml:"id,attr"` // Attribute
}

In this example:

• xml:"name" maps to a child element <name>...</name>
• xml:"contact>email" drills into a nested <contact><email>...</email></contact>
• xml:"id,attr" reads the id attribute from the <person> tag

Parse XML from a String

Use xml.Unmarshal to convert XML data into a struct:

package main

import (
    "encoding/xml"
    "fmt"
    "log"
)

func main() {
    data := `
    <person id="123">
        <name>John Doe</name>
        <age>30</age>
        <contact>
            <email>john@example.com</email>
            <phone>555-1234</phone>
        </contact>
    </person>`

    var person Person
    err := xml.Unmarshal([]byte(data), &person)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", person)
    // Output: {XMLName:{Space: Local:person} Name:John Doe Age:30 Email:john@example.com Phone:555-1234 ID:123}
}

Parse XML from a File

To read XML from a file, open it and pass the file reader to xml.NewDecoder:

package main

import (
    "encoding/xml"
    "os"
    "log"
)

func main() {
    file, err := os.Open("data.xml")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    var person Person
    decoder := xml.NewDecoder(file)
    err = decoder.Decode(&person)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", person)
}

Using xml.NewDecoder is memory-efficient for large files since it parses incrementally.

Handle Lists and Repeated Elements

For XML with repeated elements (like a list of users), use slices in your struct:

type Users struct {
    XMLName xml.Name `xml:"users"`
    People  []Person `xml:"person"`
}

With XML like:

<users>
    <person id="1"><name>Alice</name><age>25</age></person>
    <person id="2"><name>Bob</name><age>28</age></person>
</users>

You can unmarshal it the same way:

var users Users
err := xml.Unmarshal([]byte(data), &users)
if err != nil {
    log.Fatal(err)
}

Now users.People will contain two Person entries.

Tips and Gotchas

• Case sensitivity: XML element names are case-sensitive. Make sure your struct tags match exactly.
• Namespace handling: If XML uses namespaces, you may need to handle them manually using xml.Name or preprocessing.
• Optional fields: Use pointers or omitempty-like logic (though it's less common in XML than JSON).
• Unknown elements: You can use xml:",any" to capture unknown child elements if needed.

Parsing XML in Go is clean and efficient when you model your structs correctly. Just define the structure, use proper tags, and choose between Unmarshal for small data and xml.Decoder for streams or large files.

Basically, it's not complicated — just pay attention to nesting, attributes, and types.

The above is the detailed content of How to parse XML data in Go. For more information, please follow other related articles on the PHP Chinese website!