Formateador de XML

¿Qué es el formateo de XML?

El formateo de XML (también llamado pretty-printing o embellecimiento de XML) es el proceso de añadir indentación y saltos de línea consistentes a un documento XML para que su estructura jerárquica sea visible. El XML en bruto que devuelven las APIs, los generadores de configuración o los serializadores suele entregarse como una sola línea sin espacios en blanco entre las etiquetas. Un formateador de XML analiza ese documento como un árbol y lo vuelve a serializar con un espaciado predecible. El resultado es visualmente claro y mucho más fácil de comprender, sin que el contenido lógico del documento cambie en absoluto.

La especificación XML 1.0 (Recomendación W3C, quinta edición) define una gramática estricta en la que cada etiqueta de apertura debe tener su correspondiente etiqueta de cierre o ser auto-cerrada, los atributos deben ir entre comillas, y cinco caracteres (<, >, &, ", ') requieren escape mediante entidades. Un formateador debe respetar estas reglas mientras inserta únicamente espacios en blanco insignificantes que no alteren el conjunto de información (infoset) del documento.

El XML formateado es más fácil de leer durante las revisiones de código, más fácil de comparar en el control de versiones y más fácil de depurar cuando un servicio devuelve datos inesperados. La operación de formateo es sin pérdida: el contenido lógico del documento permanece idéntico, solo cambia la presentación. Herramientas como git diff y las plataformas de revisión de pull requests muestran solo las líneas modificadas — un XML con indentación consistente garantiza que esas diferencias reflejen cambios reales, no ruido de reformateo.

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

¿Por qué usar un formateador de XML online?

Formatear XML a mano es propenso a errores y lento, especialmente en documentos con anidamiento profundo o espacios de nombres mezclados. Un formateador en el navegador te da el resultado formateado en menos de un segundo, independientemente del tamaño del archivo. A diferencia de las herramientas de escritorio o las utilidades de línea de comandos, no requiere instalación ni configuración previa: simplemente abre la página y comienza a trabajar de inmediato.

Casos de uso del Formateador de XML

Referencia de entidades predefinidas de XML

XML reserva cinco caracteres para su sintaxis. Cuando estos caracteres aparecen como contenido de texto literal o valores de atributos, deben reemplazarse con referencias a entidades predefinidas. Un formateador correcto preserva estas entidades durante el pretty-printing.

Estilos de indentación XML comparados

No existe un estándar único para la indentación XML. La elección depende de las convenciones de tu equipo y las herramientas de tu pipeline. Estos son los tres estilos más comunes.

Ejemplos de código: Formatear XML por programa

Cuando necesitas formatear XML dentro de un script o proceso de compilación, cada lenguaje principal tiene una opción integrada o de biblioteca estándar. A continuación hay ejemplos funcionales que puedes copiar directamente.

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

Preguntas frecuentes