How does a simple xml element unmarshal to a golan

Question

Assume the following xml element, with an attribute and a floating point value:

<thing prop="1">
  1.23
</thing>
<thing prop="2">
  4.56
</thing>

In order to unmarshal it, how should I define my struct?

type ThingElem struct {
    Prop  int   `xml:"prop,attr"`
    Value float // ???
}

type ThingWrapper struct {
    T ThingElem `xml:"thing"`
}

// VS

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

The usage of the XMLName Property confuses me. When should it be placed in the struct, and when in a wrapper as tag?

Answer 1

Below you can find the code to unmarshal the given data.

1. The float values cannot be correctly unmarshalled until you get rid of spaces.
2. The contents of the tag can be referenced using ",chardata" annotation.
3. You do not need to specify xml.Name field in structure as long as it is not ambiguous which structure should be used.

---

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)
}