Travailler avec XML en Go : encoding/xml, bibliothèques et exemples

Travailler avec XML en Go (Golang) : guide complet avec exemples

Go (Golang) offre un support intégré pour travailler avec XML via le package encoding/xml. Ce package fournit des outils puissants pour le parsing (lecture), la génération (écriture) et la sérialisation de données au format XML. Contrairement à JSON, XML nécessite une structure plus stricte et la prise en charge des espaces de noms (namespaces), ce qui rend encoding/xml particulièrement flexible.

Dans cet article, nous allons détailler comment travailler avec XML en Go : de l'unmarshalling de base (conversion de XML en structures Go) à la création de documents XML complexes avec attributs et espaces de noms.

Bases : structures et balises XML

Pour faire correspondre les éléments XML aux champs des structures Go, on utilise des balises spéciales xml. Elles définissent le nom de l'élément, les attributs et le comportement lors de la sérialisation.

type Person struct {    XMLName   xml.Name `xml:"person"`    ID        int      `xml:"id,attr"`    Name      string   `xml:"name"`    Age       int      `xml:"age"`    Email     string   `xml:"email,omitempty"`    Addresses []Address `xml:"address"`}

type Address struct {    City    string `xml:"city"`    Street  string `xml:"street"`    ZipCode string `xml:"zip"`}

• xml:"person" — nom de l'élément racine.
• xml:"id,attr" — le champ devient un attribut de l'élément.
• xml:"email,omitempty" — le champ est ignoré s'il est vide.
• xml:"address" — le tableau sera sérialisé comme plusieurs éléments imbriqués.

Parsing XML : unmarshalling (Unmarshal)

La fonction xml.Unmarshal convertit des octets XML en une structure Go. Voici un exemple avec notre type Person :

package main

import (    "encoding/xml"    "fmt")

func main() {    xmlData := `<person id="123">    <name>Иван Петров</name>    <age>30</age>    <email>ivan@example.com</email>    <address>        <city>Москва</city>        <street>Тверская, 1</street>        <zip>101000</zip>    </address></person>`

    var p Person    err := xml.Unmarshal([]byte(xmlData), &p)    if err != nil {        fmt.Printf("Erreur de parsing : %v", err)        return    }

    fmt.Printf("ID : %d", p.ID)    fmt.Printf("Nom : %s", p.Name)    fmt.Printf("Âge : %d", p.Age)    fmt.Printf("Ville : %s", p.Addresses[0].City)}

Sortie du programme :

ID : 123Nom : Иван ПетровÂge : 30Ville : Москва

Génération XML : marshalling (Marshal)

Pour créer du XML à partir d'une structure, on utilise xml.Marshal ou xml.MarshalIndent (avec indentation).

func main() {    p := Person{        ID:   456,        Name: "Анна Смирнова",        Age:  25,        Email: "anna@example.com",        Addresses: []Address{            {City: "Санкт-Петербург", Street: "Невский, 10", ZipCode: "191186"},        },    }

    output, err := xml.MarshalIndent(p, "", "  ")    if err != nil {        fmt.Printf("Erreur de sérialisation : %v", err)        return    }

    fmt.Println(string(output))}

Résultat :

<person id="456">  <name>Анна Смирнова</name>  <age>25</age>  <email>anna@example.com</email>  <address>    <city>Санкт-Петербург</city>    <street>Невский, 10</street>    <zip>191186</zip>  </address></person>

Travailler avec les espaces de noms (Namespaces)

Les espaces de noms XML sont gérés via le champ XMLName avec l'attribut xmlns.

type Document struct {    XMLName xml.Name `xml