How to Unmarshal XML Elements with Attributes and Floating-Point Values in Go?

Unmarshalling XML Elements with Attributes and Floating-Point Values in Go

To unmarshal an XML element like the one provided, with an attribute and a floating-point value, we need to define a Go struct that corresponds to the XML structure.

Defining the Struct

Let's consider the two struct definitions given in the question:

First Definition:

<code class="go">type ThingElem struct {
    Prop  int   `xml:"prop,attr"`
    Value float // ???
}

type ThingWrapper struct {
    T ThingElem `xml:"thing"`
}</code>

Second Definition:

<code class="go">type ThingElem struct {
    XMLName xml.Name `xml:"thing"` // Do I even need this?
    Prop    int      `xml:"prop,attr"`
    Value   float    // ???
}</code>

Addressing the Options:

• XMLName Property: The XMLName property should generally be used to specify the XML element name for the struct, so we don't need it in this case since the element name is explicitly specified in the xml:"thing" annotation.
• Float Value Representation: The float field in the first struct can't be unmarshaled correctly because the floating-point values in the XML contain spaces. We need to remove these spaces before unmarshaling.
• Wrapper or Direct Embedding: The second struct definition uses a wrapper (ThingWrapper) to represent the XML element. This is not necessary since the struct ThingElem already accurately represents the XML structure.

Final Solution:

<code class="go">type Thing struct {
    Prop  int     `xml:"prop,attr"`
    Value float64 `xml:",chardata"`
}

type Root struct {
    Things []Thing `xml:"thing"`
}</code>

In this solution, the Thing struct represents a single XML element, and the Root struct is a container that holds a slice of Thing structs for unmarshaling the XML root element.

Example Code:

<code class="go">package main

import (
    "encoding/xml"
    "fmt"
)

const xmlData = `
<root>
<thing prop="1">1.23</thing>
<thing prop="2">4.56</thing>
</root>
`

func main() {
    root := &Root{}
    if err := xml.Unmarshal([]byte(xmlData), root); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(root.Things)
}</code>

This code demonstrates how to unmarshal the XML element into a Go struct, including the removal of spaces from the floating-point values.

The above is the detailed content of How to Unmarshal XML Elements with Attributes and Floating-Point Values in Go?. For more information, please follow other related articles on the PHP Chinese website!