Go言語 – XML Decoder の基本的な使い方について解説

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
// XMLデータに対応する構造体
type Person struct {
	XMLName xml.Name `xml:"person"` // ルートタグに対応
	Name    string   `xml:"name"`   // <name>タグに対応
	Age     int      `xml:"age"`    // <age>タグに対応
}
func main() {
	// サンプルXMLデータ
	xmlData := `<person>
		<name>太郎</name>
		<age>30</age>
	</person>`
	// XML文字列をReaderに変換して、Decode開始
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var p Person
	// Decode実行
	if err := decoder.Decode(&p); err != nil {
		fmt.Println("エラー:", err)
		return
	}
	fmt.Printf("名前: %s, 年齢: %d\n", p.Name, p.Age)
}

名前: 太郎, 年齢: 30

package main
import (
	"encoding/xml"
	"fmt"
	"os"
	"strings"
)
func main() {
	// サンプルXMLデータを生成
	xmlData := `<items>
		<item>Item1</item>
		<item>Item2</item>
	</items>`
	// XMLデータをReaderに変換
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	// トークンごとに処理
	for {
		token, err := decoder.Token()
		if err != nil {
			break
		}
		// トークンの内容を出力
		fmt.Printf("Token: %#v\n", token)
	}
}

Token: xml.Directive{Inst:"xml version=\"1.0\" encoding=\"UTF-8\""}
Token: xml.StartElement{Name:xml.Name{Space:"", Local:"items"}, Attr:[]xml.Attr(nil)}
Token: xml.StartElement{Name:xml.Name{Space:"", Local:"item"}, Attr:[]xml.Attr(nil)}
Token: xml.CharData("Item1")
Token: xml.EndElement{Name:xml.Name{Space:"", Local:"item"}}
Token: xml.StartElement{Name:xml.Name{Space:"", Local:"item"}, Attr:[]xml.Attr(nil)}
Token: xml.CharData("Item2")
Token: xml.EndElement{Name:xml.Name{Space:"", Local:"item"}}
Token: xml.EndElement{Name:xml.Name{Space:"", Local:"items"}}

package main
import (
	"encoding/xml"
	"fmt"
	"os"
)
type Config struct {
	XMLName xml.Name `xml:"config"`
	Version string   `xml:"version"`
}
func main() {
	// XMLファイルをオープン
	file, err := os.Open("config.xml")
	if err != nil {
		fmt.Println("ファイルオープンエラー:", err)
		return
	}
	defer file.Close()
	var config Config
	decoder := xml.NewDecoder(file)
	if err := decoder.Decode(&config); err != nil {
		fmt.Println("デコードエラー:", err)
		return
	}
	fmt.Printf("Config Version: %s\n", config.Version)
}

Config Version: 1.0

<book>
	<title>Go入門</title>
	<author>山田太郎</author>
</book>

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Book struct {
	XMLName xml.Name `xml:"book"`
	Title   string   `xml:"title"`
	Author  string   `xml:"author"`
}
func main() {
	xmlData := `<book>
		<title>Go入門</title>
		<author>山田太郎</author>
	</book>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var book Book
	if err := decoder.Decode(&book); err != nil {
		fmt.Println("デコードエラー:", err)
		return
	}
	fmt.Printf("タイトル: %s, 著者: %s\n", book.Title, book.Author)
}

タイトル: Go入門, 著者: 山田太郎

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Library struct {
	XMLName xml.Name `xml:"library"`
	Books   []Book   `xml:"book"`
}
type Book struct {
	Title  string `xml:"title"`
	Author string `xml:"author"`
}
func main() {
	xmlData := `<library>
		<book>
			<title>Go入門</title>
			<author>山田太郎</author>
		</book>
		<book>
			<title>XML活用</title>
			<author>佐藤花子</author>
		</book>
	</library>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var library Library
	if err := decoder.Decode(&library); err != nil {
		fmt.Println("デコードエラー:", err)
		return
	}
	for _, book := range library.Books {
		fmt.Printf("タイトル: %s, 著者: %s\n", book.Title, book.Author)
	}
}

タイトル: Go入門, 著者: 山田太郎
タイトル: XML活用, 著者: 佐藤花子

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Employee struct {
	XMLName xml.Name `xml:"employee"`
	Name    string   `xml:"name"`
	Role    string   `xml:"role"`
}
func main() {
	// サンプルXMLデータ
	xmlData := `<employee>
		<name>鈴木一郎</name>
		<role>エンジニア</role>
	</employee>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var emp Employee
	// XMLデコード処理
	if err := decoder.Decode(&emp); err != nil {
		fmt.Println("XMLデコードエラー:", err)
		return
	}
	// 結果出力
	fmt.Printf("従業員名: %s, 役職: %s\n", emp.Name, emp.Role)
}

従業員名: 鈴木一郎, 役職: エンジニア

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Order struct {
	XMLName xml.Name `xml:"order"`
	ID      string   `xml:"id"`
	Amount  int      `xml:"amount"`
}
func main() {
	// 故意に不正なXMLデータ(終了タグが不足)
	xmlData := `<order>
		<id>12345</id>
		<amount>100</amount>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var order Order
	// XMLデコード処理
	if err := decoder.Decode(&order); err != nil {
		// エラー検出時はエラーメッセージを出力
		fmt.Println("デコード中にエラーが発生しました:", err)
		return
	}
	fmt.Printf("注文ID: %s, 金額: %d\n", order.ID, order.Amount)
}

デコード中にエラーが発生しました: EOF

<ns:product xmlns:ns="http://example.com/ns">
	<ns:name>製品A</ns:name>
</ns:product>

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Product struct {
	XMLName xml.Name `xml:"http://example.com/ns product"`
	Name    string   `xml:"http://example.com/ns name"`
}
func main() {
	xmlData := `<ns:product xmlns:ns="http://example.com/ns">
		<ns:name>製品A</ns:name>
	</ns:product>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var prod Product
	if err := decoder.Decode(&prod); err != nil {
		fmt.Println("デコードエラー:", err)
		return
	}
	fmt.Printf("製品名: %s\n", prod.Name)
}

製品名: 製品A

package main
import (
	"encoding/xml"
	"fmt"
	"strings"
)
type Message struct {
	XMLName xml.Name `xml:"message"`
	Content string   `xml:"content"`
}
func main() {
	// エスケープされた文字列を含むXMLデータ
	xmlData := `<message>
		<content>こんにちは &amp; ようこそ</content>
	</message>`
	decoder := xml.NewDecoder(strings.NewReader(xmlData))
	var msg Message
	if err := decoder.Decode(&msg); err != nil {
		fmt.Println("デコードエラー:", err)
		return
	}
	fmt.Printf("内容: %s\n", msg.Content)
}

内容: こんにちは & ようこそ