Minificatore XML

Cos'è la minificazione XML?

La minificazione XML è il processo di rimozione di tutti i caratteri non necessari da un documento XML senza alterarne il significato. Un minificatore XML elimina gli spazi tra i tag, rimuove i commenti, sopprime le interruzioni di riga e comprime l'indentazione per produrre un output compatto su una singola riga. Il risultato è una stringa XML che i parser interpretano in modo identico alla versione formattata originale, producendo lo stesso modello di dati.

La specifica XML 1.0 (W3C Recommendation, quinta edizione) definisce le regole per la gestione degli spazi nella sezione 2.10. Gli spazi tra i tag privi di valore semantico sono chiamati "spazi non significativi." I processori XML sono autorizzati a scartarli. Gli spazi all'interno del contenuto testuale, invece, sono significativi per impostazione predefinita, a meno che l'elemento padre non dichiari xml:space="default". Un corretto minificatore XML distingue tra questi due casi e rimuove solo ciò che è sicuro rimuovere.

La minificazione differisce dalla compressione. Gzip o Brotli riducono la dimensione a livello di trasporto e richiedono la decompressione prima del parsing. La minificazione riduce direttamente la dimensione del documento grezzo, quindi l'XML rimane valido e leggibile da qualsiasi parser senza alcun passaggio di decompressione. In pratica, minificare prima di comprimere produce i risultati migliori: si eliminano prima i caratteri ridondanti, poi l'algoritmo di compressione lavora su un input più compatto.

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

Perché usare un minificatore XML?

L'XML formattato con indentazione e commenti è ideale per lo sviluppo e la revisione del codice. Per l'archiviazione, la trasmissione e il consumo automatizzato, quella formattazione aggiuntiva aggiunge byte senza alcun beneficio. Un minificatore XML colma questo divario.

Casi d'uso del Minificatore XML

Cosa rimuove la minificazione XML

Non tutto ciò che si trova in un documento XML può essere rimosso in sicurezza. Questa tabella di riferimento mostra ogni tipo di contenuto eliminabile e se scartarlo è sempre sicuro o condizionale al caso d'uso.

Minificazione vs Gzip vs Formati binari

Minificazione, compressione e codifica binaria puntano ciascuna a un livello diverso del problema delle dimensioni. La minificazione mantiene l'output come XML valido e leggibile dall'essere umano. La compressione (gzip, Brotli) riduce ulteriormente ma richiede un passaggio di decompressione prima del parsing. I formati binari vanno oltre, ma entrambi i lati della connessione necessitano di un encoder/decoder compatibile — pratico principalmente per sistemi embedded o servizi enterprise con WSDL intensivo.

Esempi di codice

La minificazione programmatica di XML segue lo stesso schema in ogni linguaggio: si analizza il documento in un albero, si rimuovono opzionalmente i nodi di commento, poi si serializza senza indentazione.

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

Domande frequenti