General XML parser in Go

Is there some general approach of reading XML document in Go? Something similar to XmlDocument or XDocument in C#?

All the examples I found show how to read using unmarshaling functionality into the objects I need to define, but it's quite time consuming as I need to define a lot of staff that I'm not going to use.

xml.Unmarshal(...)

Another approach is forward only reading using:

xml.NewDecoder(xmlFile) 

Described here: http://blog.davidsingleton.org/parsing-huge-xml-files-with-go/

> All the examples I found show how to read using unmarshaling functionality into the objects I need to define, but it's quite time consuming as I need to define a lot of staff that I'm not going to use.

Then don't define what you're not going to use, define only what you're going to use. You don't have to create a Go model that perfectly covers the XML structure.

Let's assume you have an XML like this:

<blog id="1234">
	<meta keywords="xml,parsing,partial" />
	<name>Partial XML parsing</name>
	<url>http://somehost.com/xml-blog</url>
	<entries count="2">
		<entry time="2016-01-19 08:40:00">
			<author>Bob</author>
			<content>First entry</content>
		</entry>
		<entry time="2016-01-19 08:30:00">
			<author>Alice</author>
			<content>Second entry</content>
		</entry>
	</entries>
</blog>

And let's assume you only need the following info out of this XML:

• id
• keywords
• blog name
• authors names

You can model these wanted pieces of information with the following struct:

type Data struct {
	Id   string `xml:"id,attr"`
	Meta struct {
		Keywords string `xml:"keywords,attr"`
	} `xml:"meta"`
	Name    string   `xml:"name"`
	Authors []string `xml:"entries>entry>author"`
}

And now you can parse only these information with the following code:

d := Data{}
if err := xml.Unmarshal([]byte(s), &d); err != nil {
	panic(err)
}
fmt.Printf("%+v", d)

Output (try it on the Go Playground):

{Id:1234 Meta:{Keywords:xml,parsing,partial} Name:Partial XML parsing Authors:[Bob Alice]}

Well, two things.

First, you are not obliged to define Go types which map to complex elements to parse XML with nothing but encoding/xml.
On the contrary, you can parse XML documents purely procedurally and calling xml.Unmarshal() only on primitive (non-nested) elements—to parse them as values of "primitive" types (such as string or int32 or time.Time etc).

That would be a lot of code, for sure, but that's just approaching the same problem from a more dynamic angle. To understand what I mean, consider your fully-parsed XML document in the form of a DOM object. To extract useful data from it, you have to query that object somehow or iterate over the tree. With the approach the blog post you've referred to presents, you traverse your XML document as you parse it—essentially combining parsing with querying/traversing.

This may or may not work for you as applicability of a particular approach to parsing of XML-formatted datum highly depends on its structure and the intended outcome of its parsing. For instance, if you need to perform several queries over the document with the later queries depending on the former, procedural decoding from that blog post hardly works.

Second, alternative libraries exist. For instance, look at xmltree and xmlpath.
While these two are written in pure Go, there exist a couple of packages wrapping libxml, for instance, goxml. With them, you can have DOM-oriented parsing if you like.

Yet another approach is to parse XML into a set of nested key/value maps using mxj.