Formateur XML

Qu'est-ce que le formatage XML ?

Le formatage XML (également appelé pretty-printing ou embellissement XML) est le processus consistant à ajouter une indentation et des sauts de ligne cohérents à un document XML afin de rendre visible sa structure hiérarchique. Le XML brut provenant d'API, de générateurs de configuration ou de sérialiseurs est souvent livré sur une seule ligne sans espace entre les balises. Un formateur XML analyse ce document en un arbre, puis le resérialise avec un espacement prévisible. Le résultat est visuellement clair et beaucoup plus facile à comprendre, sans qu'aucune information du document ne soit modifiée.

La spécification XML 1.0 (recommandation W3C, cinquième édition) définit une grammaire stricte dans laquelle chaque balise ouvrante doit avoir une balise fermante correspondante ou être auto-fermante, les attributs doivent être entre guillemets, et cinq caractères (<, >, &, ", ') nécessitent un échappement par entités. Un formateur doit respecter ces règles tout en insérant uniquement des espaces blancs non significatifs qui ne modifient pas l'ensemble d'informations (infoset) du document.

Un XML formaté est plus facile à lire lors des revues de code, plus facile à comparer dans le contrôle de version, et plus facile à déboguer lorsqu'un service renvoie des données inattendues. L'opération de formatage est elle-même sans perte : le contenu logique du document reste identique, seule la présentation change. Des outils comme git diff et les plateformes de révision de pull requests n'affichent que les lignes modifiées — un XML correctement indenté garantit que ces diffs reflètent de vraies modifications, et non du bruit de reformatage.

<catalog><book id="bk101"><author>Gambardella, Matthew</author><title>XML Developer's Guide</title><genre>Computer</genre><price>44.95</price><publish_date>2000-10-01</publish_date></book><book id="bk102"><author>Ralls, Kim</author><title>Midnight Rain</title><genre>Fantasy</genre><price>5.95</price><publish_date>2000-12-16</publish_date></book></catalog>

<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer's Guide</title>
    <genre>Computer</genre>
    <price>44.95</price>
    <publish_date>2000-10-01</publish_date>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <genre>Fantasy</genre>
    <price>5.95</price>
    <publish_date>2000-12-16</publish_date>
  </book>
</catalog>

Pourquoi utiliser un formateur XML en ligne ?

Formater du XML à la main est laborieux et source d'erreurs, en particulier pour des documents avec une imbrication profonde ou des espaces de noms mixtes. Un formateur dans le navigateur vous donne un résultat formaté en moins d'une seconde, quelle que soit la taille du fichier.

Cas d'utilisation du formateur XML

Référence des entités prédéfinies XML

XML réserve cinq caractères pour sa syntaxe. Lorsque ces caractères apparaissent dans le contenu textuel ou les valeurs d'attributs, ils doivent être remplacés par des références d'entités prédéfinies. Un formateur correct préserve ces entités lors du pretty-printing.

Comparaison des styles d'indentation XML

Il n'existe pas de norme unique pour l'indentation XML. Le choix dépend des conventions de votre équipe et des outils de votre pipeline. Voici les trois styles les plus courants.

Exemples de code : formater XML par programmation

Lorsque vous devez formater du XML dans un script ou un processus de build, chaque langage majeur dispose d'une option intégrée ou dans sa bibliothèque standard. Voici des exemples fonctionnels que vous pouvez copier directement.

const raw = '<root><item>hello</item></root>'
const parser = new DOMParser()
const doc = parser.parseFromString(raw, 'application/xml')
const serializer = new XMLSerializer()
const xml = serializer.serializeToString(doc)

// Indent with XSLT (browser-native approach)
const xslt = new DOMParser().parseFromString(`
  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml" indent="yes"/>
    <xsl:template match="node()|@*">
      <xsl:copy><xsl:apply-templates select="node()|@*"/></xsl:copy>
    </xsl:template>
  </xsl:stylesheet>`, 'application/xml')

const proc = new XSLTProcessor()
proc.importStylesheet(xslt)
const formatted = proc.transformToDocument(doc)
console.log(new XMLSerializer().serializeToString(formatted))
// → <root>\n  <item>hello</item>\n</root>

import xml.dom.minidom

raw = '<root><item>hello</item><item>world</item></root>'
dom = xml.dom.minidom.parseString(raw)
print(dom.toprettyxml(indent='  '))
# → <?xml version="1.0" ?>
# → <root>
# →   <item>hello</item>
# →   <item>world</item>
# → </root>

# With lxml (handles namespaces, XSD, large files)
from lxml import etree
tree = etree.fromstring(raw.encode())
print(etree.tostring(tree, pretty_print=True).decode())

package main

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

func formatXML(raw string) (string, error) {
    decoder := xml.NewDecoder(strings.NewReader(raw))
    var out strings.Builder
    encoder := xml.NewEncoder(&out)
    encoder.Indent("", "  ")
    for {
        tok, err := decoder.Token()
        if err != nil {
            break
        }
        encoder.EncodeToken(tok)
    }
    encoder.Flush()
    return out.String(), nil
}
// formatXML("<a><b>1</b></a>") → "<a>\n  <b>1</b>\n</a>"

# Format XML file with xmllint (part of libxml2, pre-installed on macOS/Linux)
xmllint --format input.xml > formatted.xml

# Format from stdin
echo '<a><b>1</b></a>' | xmllint --format -
# → <?xml version="1.0"?>
# → <a>
# →   <b>1</b>
# → </a>

# Validate and format at the same time
xmllint --format --schema schema.xsd input.xml

Questions fréquemment posées