XML Minifier

Vad är XML-minifiering?

XML-minifiering är processen att ta bort alla onödiga tecken från ett XML-dokument utan att förändra dess innebörd. En XML-minifierare tar bort blanksteg mellan taggar, tar bort kommentarer, eliminerar radbrytningar och komprimerar indragning för att producera kompakt utdata på en enda rad. Resultatet är en XML-sträng som parsers läser identiskt med den ursprungliga formaterade versionen och som ger samma datamodell.

XML 1.0-specifikationen (W3C Recommendation, femte upplagan) definierar regler för blankstegshantering i avsnitt 2.10. Blanksteg mellan taggar som inte har något semantiskt värde kallas "insignifikant blanksteg". XML-processorer tillåts att kasta bort det. Blanksteg inuti textinnehåll är däremot som standard betydelsefullt, såvida inte förälderelementet deklarerar xml:space="default". En korrekt XML-minifierare skiljer mellan dessa två fall och tar bara bort det som är säkert att ta bort.

Minifiering skiljer sig från komprimering. Gzip eller Brotli minskar storleken på transportlagret och kräver dekomprimering innan parsning. Minifiering minskar storleken på själva rådokumentet, så XML:en förblir giltig och läsbar av alla parsers utan ett dekomprimeringsteg. I praktiken ger minifiering innan komprimering bäst resultat: du eliminerar redundanta tecken först, varefter komprimeringsalgoritmen arbetar på ett tätare indata.

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

Varför använda en XML-minifierare?

Formaterad XML med indragning och kommentarer är idealisk för utveckling och kodgranskning. För lagring, överföring och maskinbearbetning tillför den extra formateringen bytes utan någon nytta. En XML-minifierare täpper igen det gapet.

Användningsfall för XML Minifier

Vad XML-minifiering tar bort

Inte allt i ett XML-dokument kan tas bort på ett säkert sätt. Referenstabellen nedan visar varje typ av borttagbart innehåll och om det alltid är säkert att ta bort det, eller om det beror på ditt användningsfall.

Minifiering vs Gzip vs binärformat

Minifiering, komprimering och binärkodning riktar sig mot olika lager av storleksproblemet. Minifiering håller utdata som giltig, mänskligt läsbar XML. Komprimering (gzip, Brotli) minskar ytterligare men kräver ett dekomprimeringsteg innan parsning. Binärformat går längst, men båda ändarna av anslutningen behöver en kompatibel kodare/avkodare — vilket är praktiskt huvudsakligen för inbyggda system eller WSDL-tunga företagstjänster.

Kodexempel

Att minifiera XML programmatiskt följer samma mönster i varje språk: parsa dokumentet till ett träd, ta eventuellt bort kommentarsnoder, och serialisera sedan utan indragning.

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

Vanliga frågor