Do I Need to Use XMLName for Unmarshaling XML Elements with Attributes and Floating Point Values?

Unmarshaling XML Elements with Attributes and Floating Point Values

To unmarshal an XML element with an attribute and a floating point value, you can define a Go struct with the corresponding fields. However, there are some considerations regarding the usage of the xml.Name property.

In the provided XML element:

<code class="xml"><thing prop="1">
  1.23
</thing></code>

The ThingElem struct should have the following properties:

• Prop: This field corresponds to the attribute prop and its type is int.
• Value: This field corresponds to the floating point value 1.23.

Option 1: With XMLName

In this option, you can add an xml.Name field to the ThingElem struct. This field is typically used when the XML structure is ambiguous. In this case, it's not necessary because it's clear that the struct corresponds to the thing element.

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

Option 2: Without XMLName

Since there is no ambiguity in the XML structure, you can omit the xml.Name field.

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

Unmarshaling Floating Point Values

To correctly unmarshal the floating point value, you need to ensure that there are no spaces in the XML. In your example, the value is 1.23, but it's recommended to remove the spaces and store it as 1.23.

Unmarshaling Nested Data

You can also unmarshal nested data by defining a wrapper struct. For example, the XML contains multiple thing elements. To unmarshal them, you would define a ThingWrapper struct:

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

Complete Code Example

Here's a complete code example that unmarshals the provided XML data:

<code class="go">package main

import (
    "encoding/xml"
    "fmt"
)

type Root struct {
    Things []Thing `xml:"thing"`
}

type Thing struct {
    Prop  int     `xml:"prop,attr"`
    Value float64 `xml:",chardata"`
}

func main() {
    data := `<root><thing prop="1">1.23</thing><thing prop="2">4.56</thing></root>`
    thing := &Root{}
    err := xml.Unmarshal([]byte(data), thing)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(thing)
}</code>

This code will print the parsed XML data, including the prop attribute and the floating point values.

The above is the detailed content of Do I Need to Use XMLName for Unmarshaling XML Elements with Attributes and Floating Point Values?. For more information, please follow other related articles on the PHP Chinese website!