XML Minifier

Was ist XML-Minifizierung?

XML-Minifizierung ist der Prozess, alle nicht notwendigen Zeichen aus einem XML-Dokument zu entfernen, ohne dessen Bedeutung zu ändern. Ein XML Minifier entfernt Leerzeichen zwischen Tags, löscht Kommentare, beseitigt Zeilenumbrüche und reduziert Einrückungen, um eine kompakte, einzeilige Ausgabe zu erzeugen. Das Ergebnis ist eine XML-Zeichenkette, die Parser identisch zum ursprünglich formatierten Dokument verarbeiten und das gleiche Datenmodell erzeugen.

Die XML-1.0-Spezifikation (W3C-Empfehlung, fünfte Ausgabe) definiert Regeln zur Leerzeichenbehandlung in Abschnitt 2.10. Leerzeichen zwischen Tags ohne semantischen Wert werden als "nicht wesentlicher Leerraum" bezeichnet. XML-Prozessoren dürfen diesen verwerfen. Leerzeichen innerhalb von Textinhalten sind hingegen standardmäßig bedeutsam, sofern das übergeordnete Element nicht xml:space="default" deklariert. Ein korrekter XML Minifier unterscheidet zwischen diesen beiden Fällen und entfernt nur das, was sicher entfernt werden kann.

Minifizierung unterscheidet sich von Komprimierung. Gzip oder Brotli reduzieren die Größe auf der Transportschicht und erfordern eine Dekomprimierung vor dem Parsen. Minifizierung reduziert die Rohgröße des Dokuments selbst, sodass das XML gültig bleibt und von jedem Parser ohne Dekomprimierungsschritt lesbar ist. In der Praxis liefert das Minifizieren vor dem Komprimieren die besten Ergebnisse: Redundante Zeichen werden zuerst entfernt, anschließend arbeitet der Komprimierungsalgorithmus auf einer kompakteren Eingabe.

<?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>

Warum einen XML Minifier verwenden?

Formatiertes XML mit Einrückungen und Kommentaren ist ideal für die Entwicklung und Code-Reviews. Für Speicherung, Übertragung und maschinelle Verarbeitung fügen diese Formatierungszeichen Bytes ohne Mehrwert hinzu. Ein XML Minifier schließt diese Lücke.

Anwendungsfälle für den XML Minifier

Was XML-Minifizierung entfernt

Nicht alles in einem XML-Dokument kann sicher entfernt werden. Diese Referenztabelle zeigt jeden Typ entfernbaren Inhalts und gibt an, ob das Verwerfen stets sicher oder vom Anwendungsfall abhängig ist.

Minifizierung vs. Gzip vs. Binärformate

Minifizierung, Komprimierung und Binärkodierung adressieren jeweils eine andere Ebene des Größenproblems. Minifizierung hält die Ausgabe als gültiges, menschenlesbares XML. Komprimierung (Gzip, Brotli) reduziert die Größe weiter, erfordert aber einen Dekomprimierungsschritt vor dem Parsen. Binärformate gehen am weitesten, benötigen jedoch auf beiden Seiten der Verbindung einen kompatiblen Encoder/Decoder — praktisch vor allem für eingebettete Systeme oder WSDL-lastige Unternehmensdienste.

Code-Beispiele

XML programmatisch zu minifizieren folgt in jeder Sprache dem gleichen Muster: das Dokument in einen Baum parsen, optional Kommentar-Knoten entfernen, dann ohne Einrückung serialisieren.

// 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"

Häufig gestellte Fragen