Minificateur XML

Qu'est-ce que la minification XML ?

La minification XML est le processus qui consiste à supprimer tous les caractères superflus d'un document XML sans en modifier le sens. Un minificateur XML supprime les espaces entre les balises, retire les commentaires, élimine les sauts de ligne et réduit l'indentation pour produire une sortie compacte sur une seule ligne. Le résultat est une chaîne XML que les parseurs lisent de manière identique à la version formatée d'origine, en produisant le même modèle de données.

La spécification XML 1.0 (Recommandation W3C, cinquième édition) définit les règles de gestion des espaces à la section 2.10. Les espaces entre les balises sans valeur sémantique sont appelés « espaces non significatifs ». Les processeurs XML sont autorisés à les ignorer. En revanche, les espaces à l'intérieur du contenu textuel sont significatifs par défaut, sauf si l'élément parent déclare xml:space="default". Un minificateur XML correct distingue ces deux cas et ne supprime que ce qu'il est sûr de supprimer.

La minification diffère de la compression. Gzip ou Brotli réduisent la taille au niveau de la couche de transport et nécessitent une décompression avant l'analyse. La minification réduit la taille brute du document lui-même : le XML reste valide et lisible par n'importe quel parseur sans étape de décompression. En pratique, minifier avant de compresser donne les meilleurs résultats : on élimine d'abord les caractères redondants, puis l'algorithme de compression travaille sur une entrée plus compacte.

<?xml version="1.0" encoding="UTF-8"?>
<!-- Product catalog for Q1 2026 -->
<catalog>
  <product id="p101">
    <name>Widget A</name>
    <price currency="USD">29.99</price>
    <!-- Temporarily discounted -->
    <stock>142</stock>
  </product>
  <product id="p102">
    <name>Widget B</name>
    <price currency="EUR">19.50</price>
    <stock>87</stock>
  </product>
</catalog>

<?xml version="1.0" encoding="UTF-8"?><catalog><product id="p101"><name>Widget A</name><price currency="USD">29.99</price><stock>142</stock></product><product id="p102"><name>Widget B</name><price currency="EUR">19.50</price><stock>87</stock></product></catalog>

Pourquoi utiliser un minificateur XML ?

Un XML bien formaté avec indentation et commentaires est idéal pour le développement et la revue de code. Pour le stockage, la transmission et la consommation machine, ce formatage supplémentaire ajoute des octets sans aucun bénéfice. Un minificateur XML comble cet écart.

Cas d'usage du minificateur XML

Ce que la minification XML supprime

Tout ce qui se trouve dans un document XML ne peut pas être supprimé sans risque. Ce tableau de référence présente chaque type de contenu supprimable et indique si le fait de le retirer est toujours sûr ou conditionnel selon votre cas d'usage.

Minification vs Gzip vs formats binaires

La minification, la compression et l'encodage binaire ciblent chacun une couche différente du problème de taille. La minification conserve la sortie sous forme de XML valide et lisible par l'humain. La compression (gzip, Brotli) réduit davantage mais nécessite une étape de décompression avant l'analyse. Les formats binaires vont le plus loin, mais les deux extrémités de la connexion ont besoin d'un encodeur/décodeur compatible — utile principalement pour les systèmes embarqués ou les services d'entreprise à forte utilisation de WSDL.

Exemples de code

La minification de XML par programme suit le même schéma dans tous les langages : on analyse le document en arbre, on supprime optionnellement les nœuds de commentaires, puis on sérialise sans indentation.

// Minify XML by parsing and re-serializing (strips formatting)
const raw = `<root>
  <item id="1">
    <!-- note -->
    <name>Test</name>
  </item>
</root>`

const parser = new DOMParser()
const doc = parser.parseFromString(raw, 'application/xml')

// Remove comment nodes
const walker = doc.createTreeWalker(doc, NodeFilter.SHOW_COMMENT)
const comments = []
while (walker.nextNode()) comments.push(walker.currentNode)
comments.forEach(c => c.parentNode.removeChild(c))

const minified = new XMLSerializer().serializeToString(doc)
// → "<root><item id=\"1\"><name>Test</name></item></root>"

from lxml import etree

xml = """<root>
  <item id="1">
    <!-- note -->
    <name>Test</name>
  </item>
</root>"""

tree = etree.fromstring(xml.encode())

# Remove comments
for comment in tree.iter(etree.Comment):
    comment.getparent().remove(comment)

# Serialize without pretty-print (minified)
result = etree.tostring(tree, xml_declaration=False).decode()
# → '<root><item id="1"><name>Test</name></item></root>'

# With xml.etree (stdlib, no lxml needed)
import xml.etree.ElementTree as ET
root = ET.fromstring(xml)
ET.indent(root, space='')  # Python 3.9+
print(ET.tostring(root, encoding='unicode'))

package main

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

func minifyXML(input string) (string, error) {
    decoder := xml.NewDecoder(strings.NewReader(input))
    var out strings.Builder
    encoder := xml.NewEncoder(&out)
    // No indentation = minified output
    for {
        tok, err := decoder.Token()
        if err != nil {
            break
        }
        // Skip comments
        if _, ok := tok.(xml.Comment); ok {
            continue
        }
        // Skip whitespace-only char data
        if cd, ok := tok.(xml.CharData); ok {
            if strings.TrimSpace(string(cd)) == "" {
                continue
            }
        }
        encoder.EncodeToken(tok)
    }
    encoder.Flush()
    return out.String(), nil
}
// minifyXML("<a>\n  <b>1</b>\n</a>") → "<a><b>1</b></a>"

# Minify XML with xmllint (part of libxml2)
xmllint --noblanks input.xml > minified.xml

# Minify from stdin
echo '<root>
  <item>hello</item>
</root>' | xmllint --noblanks -
# → <?xml version="1.0"?><root><item>hello</item></root>

# Strip comments too (combine with sed or xmlstarlet)
xmlstarlet ed -d '//comment()' input.xml | xmllint --noblanks -

# Check size reduction
echo "Before: $(wc -c < input.xml) bytes"
echo "After:  $(xmllint --noblanks input.xml | wc -c) bytes"

Questions fréquentes