Travailler avec XML en Go (Golang) : la bibliothèque standard encoding/xml

Travailler avec XML en Go (Golang) : guide détaillé du package encoding/xml

Dans le développement moderne en Go (Golang), la tâche de traitement des données XML est assez courante — de l'intégration avec des systèmes hérités à l'échange de données dans les services SOAP. La bibliothèque standard de Go fournit un package puissant et flexible encoding/xml, qui permet d'analyser, créer et transformer efficacement des documents XML. Dans cet article, nous allons détailler toutes les fonctionnalités clés pour travailler avec XML en Go.

Principales fonctionnalités du package encoding/xml

Le package encoding/xml implémente une interface simple pour la sérialisation (marshaling) des structures Go en XML et la désérialisation (unmarshaling) du XML en structures. Il prend en charge :

• La conversion des structures Go en documents XML et vice versa
• Le travail avec les attributs, les éléments imbriqués et les espaces de noms
• L'analyse en flux de grands fichiers XML via xml.Decoder
• Des règles de sérialisation personnalisables à l'aide de balises de structure

Installation et importation du package

Le package encoding/xml fait partie de la bibliothèque standard de Go, donc aucune installation supplémentaire n'est nécessaire. Pour l'utiliser, il suffit de l'importer :

import (    "encoding/xml"    "fmt"    "os")

Marshaling : structure Go → XML

Pour convertir une structure Go en XML, on utilise la fonction xml.Marshal() ou xml.MarshalIndent() pour une sortie formatée. Voici un exemple :

type Person struct {    XMLName   xml.Name `xml:"person"`    ID        int      `xml:"id,attr"`    FirstName string   `xml:"name>first"`    LastName  string   `xml:"name>last"`    Age       int      `xml:"age"`}

func main() {    p := Person{        ID:        123,        FirstName: "Ivan",        LastName:  "Petrov",        Age:       30,    }

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

    fmt.Println(string(output))}

Résultat de l'exécution :

<person id="123">  <name>    <first>Ivan</first>    <last>Petrov</last>  </name>  <age>30</age></person>

Unmarshaling : XML → structure Go

Le processus inverse — la conversion de données XML en structure Go — s'effectue à l'aide de xml.Unmarshal() :

func unmarshalExample() {    xmlData := `<person id="456">  <name>    <first>Maria</first>    <last>Sidorova</last>  </name>  <age>25</age></person>`

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

    fmt.Printf("ID : %d, Nom : %s %s, Âge : %d", p.ID, p.FirstName, p.LastName, p.Age)    // Affichage : ID : 456, Nom : Maria Sidorova, Âge : 25}

Travailler avec les attributs et les éléments imbriqués

Le package encoding/xml utilise des balises de structure pour contrôler le mappage. Les directives de balises principales sont :

• xml:"name" — nom de l'élément
• xml:"name,attr" — attribut de l'élément
• xml:"parent>child" — élément imbriqué
• xml:",chardata" — contenu textuel
• xml:",innerxml" — XML brut à l'intérieur de l'élément
• xml:",comment" — commentaire XML
• xml:"-" — ignorer le champ

Analyse en flux de grands fichiers XML

Pour traiter de grands documents XML (par exemple, des fichiers de plusieurs gigaoctets), on utilise l'analyseur en flux xml.Decoder. Cela permet de ne pas surcharger la mémoire et de traiter les données progressivement.