Formattatore XML

Cos'è la formattazione XML?

La formattazione XML (chiamata anche pretty-printing o abbellimento XML) è il processo di aggiunta di indentazione e interruzioni di riga coerenti a un documento XML, in modo da rendere visibile la sua struttura gerarchica. L'XML grezzo proveniente da API, generatori di configurazione o serializzatori viene spesso prodotto come una singola riga senza spazi tra i tag. Un formattatore XML analizza il documento in un albero, poi lo ri-serializza con spaziatura prevedibile. Il risultato è visivamente chiaro e molto più facile da comprendere, senza che il contenuto logico del documento venga alterato in alcun modo.

La specifica XML 1.0 (W3C Recommendation, quinta edizione) definisce una grammatica rigida: ogni tag di apertura deve avere un tag di chiusura corrispondente o essere auto-chiudente, gli attributi devono essere tra virgolette, e cinque caratteri (<, >, &, ", ') richiedono il carattere di escape come entità. Un formattatore deve rispettare queste regole inserendo solo spazi non significativi che non alterano l'infoset del documento.

L'XML formattato è più facile da leggere durante la revisione del codice, più facile da confrontare nel controllo di versione e più facile da debuggare quando un servizio restituisce dati inattesi. L'operazione di formattazione è priva di perdite: il contenuto logico del documento rimane identico, cambia solo la presentazione. Strumenti come git diff e le piattaforme di revisione delle pull request mostrano solo le righe modificate — un XML con indentazione coerente garantisce che quei diff riflettano modifiche reali, non rumore di riformattazione.

<catalog><book id="bk101"><author>Gambardella, Matthew</author><title>XML Developer's Guide</title><genre>Computer</genre><price>44.95</price><publish_date>2000-10-01</publish_date></book><book id="bk102"><author>Ralls, Kim</author><title>Midnight Rain</title><genre>Fantasy</genre><price>5.95</price><publish_date>2000-12-16</publish_date></book></catalog>

<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer's Guide</title>
    <genre>Computer</genre>
    <price>44.95</price>
    <publish_date>2000-10-01</publish_date>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <genre>Fantasy</genre>
    <price>5.95</price>
    <publish_date>2000-12-16</publish_date>
  </book>
</catalog>

Perché usare un formattatore XML online?

Formattare l'XML a mano è lento e soggetto a errori, specialmente per documenti con annidamento profondo o namespace misti. Un formattatore basato su browser produce il risultato in meno di un secondo, indipendentemente dalla dimensione del file. A differenza degli strumenti desktop o delle utilità da riga di comando, non richiede installazione né configurazione: basta aprire la pagina e iniziare a lavorare immediatamente.

Casi d'uso del Formattatore XML

Riferimento alle entità predefinite XML

XML riserva cinque caratteri per la sua sintassi. Quando questi caratteri compaiono come contenuto di testo letterale o come valori di attributo, devono essere sostituiti con riferimenti a entità predefinite. Un formattatore corretto preserva queste entità durante il pretty-printing.

Stili di indentazione XML a confronto

Non esiste uno standard unico per l'indentazione XML. La scelta dipende dalle convenzioni del team e dagli strumenti nella pipeline. Ecco i tre stili più comuni.

Esempi di codice: formattare XML a livello programmatico

Quando hai bisogno di formattare XML all'interno di uno script o di un processo di build, ogni linguaggio principale dispone di un'opzione integrata o nella libreria standard. In Python si usa il modulo xml.dom.minidom o lxml, in Java è disponibile javax.xml.transform con il supporto per la spaziatura, in Node.js ci sono librerie come xmldom o prettier. Di seguito trovi esempi funzionanti che puoi copiare direttamente.

const raw = '<root><item>hello</item></root>'
const parser = new DOMParser()
const doc = parser.parseFromString(raw, 'application/xml')
const serializer = new XMLSerializer()
const xml = serializer.serializeToString(doc)

// Indent with XSLT (browser-native approach)
const xslt = new DOMParser().parseFromString(`
  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml" indent="yes"/>
    <xsl:template match="node()|@*">
      <xsl:copy><xsl:apply-templates select="node()|@*"/></xsl:copy>
    </xsl:template>
  </xsl:stylesheet>`, 'application/xml')

const proc = new XSLTProcessor()
proc.importStylesheet(xslt)
const formatted = proc.transformToDocument(doc)
console.log(new XMLSerializer().serializeToString(formatted))
// → <root>\n  <item>hello</item>\n</root>

import xml.dom.minidom

raw = '<root><item>hello</item><item>world</item></root>'
dom = xml.dom.minidom.parseString(raw)
print(dom.toprettyxml(indent='  '))
# → <?xml version="1.0" ?>
# → <root>
# →   <item>hello</item>
# →   <item>world</item>
# → </root>

# With lxml (handles namespaces, XSD, large files)
from lxml import etree
tree = etree.fromstring(raw.encode())
print(etree.tostring(tree, pretty_print=True).decode())

package main

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

func formatXML(raw string) (string, error) {
    decoder := xml.NewDecoder(strings.NewReader(raw))
    var out strings.Builder
    encoder := xml.NewEncoder(&out)
    encoder.Indent("", "  ")
    for {
        tok, err := decoder.Token()
        if err != nil {
            break
        }
        encoder.EncodeToken(tok)
    }
    encoder.Flush()
    return out.String(), nil
}
// formatXML("<a><b>1</b></a>") → "<a>\n  <b>1</b>\n</a>"

# Format XML file with xmllint (part of libxml2, pre-installed on macOS/Linux)
xmllint --format input.xml > formatted.xml

# Format from stdin
echo '<a><b>1</b></a>' | xmllint --format -
# → <?xml version="1.0"?>
# → <a>
# →   <b>1</b>
# → </a>

# Validate and format at the same time
xmllint --format --schema schema.xsd input.xml

Domande frequenti