XML Minifier

Wat is XML-minificatie?

XML-minificatie is het proces van het verwijderen van alle onnodige tekens uit een XML-document zonder de betekenis ervan te wijzigen. Een XML-minifier verwijdert witruimte tussen tags, verwijdert opmerkingen, elimineert regelafbrekingen en vouwt inspringing samen om compacte uitvoer op één regel te produceren. Het resultaat is een XML-tekenreeks die parsers identiek lezen aan de oorspronkelijke opgemaakte versie, en hetzelfde datamodel opleveren.

De XML 1.0-specificatie (W3C Recommendation, vijfde editie) definieert regels voor witruimteverwerking in sectie 2.10. Witruimte tussen tags zonder semantische waarde wordt "niet-significante witruimte" genoemd. XML-processors mogen deze negeren. Witruimte binnen tekstinhoud is echter standaard significant, tenzij het bovenliggende element xml:space="default" declareert. Een correcte XML-minifier maakt onderscheid tussen deze twee gevallen en verwijdert alleen wat veilig verwijderd kan worden.

Minificatie verschilt van compressie. Gzip of Brotli verkleinen de omvang op de transportlaag en vereisen decompressie vóór het parseren. Minificatie verkleint de onbewerkte documentgrootte zelf, zodat de XML geldig en leesbaar blijft voor elke parser zonder een decompresiestap. In de praktijk levert minificeren vóór comprimeren de beste resultaten op: u elimineert eerst overbodige tekens, waarna het compressie-algoritme op een compactere invoer werkt.

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

Waarom een XML Minifier gebruiken?

Opgemaakte XML met inspringing en opmerkingen is ideaal voor ontwikkeling en code-review. Voor opslag, verzending en machinale verwerking voegt die extra opmaak bytes toe zonder enig voordeel. Een XML-minifier overbrugt dat verschil.

Toepassingen van de XML Minifier

Wat XML-minificatie verwijdert

Niet alles in een XML-document kan veilig worden verwijderd. Deze referentietabel toont elk type verwijderbare inhoud en of het weggooien daarvan altijd veilig is of afhankelijk is van uw gebruiksscenario.

Minificatie versus Gzip versus Binaire formaten

Minificatie, compressie en binaire codering richten zich elk op een andere laag van het grootteprobleem. Minificatie houdt de uitvoer als geldige, door mensen leesbare XML. Compressie (gzip, Brotli) verkleint verder maar vereist een decompresiestap vóór het parseren. Binaire formaten gaan het verst, maar beide zijden van de verbinding hebben een compatibele encoder/decoder nodig — wat hoofdzakelijk praktisch is voor embedded systemen of WSDL-zware zakelijke diensten.

Codevoorbeelden

XML programmatisch minificeren volgt in elke taal hetzelfde patroon: parseer het document tot een boomstructuur, verwijder optioneel commentaarknooppunten en serialiseer vervolgens zonder inspringing.

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

Veelgestelde vragen