Minificador XML

¿Qué es la minificación de XML?

La minificación de XML es el proceso de eliminar todos los caracteres innecesarios de un documento XML sin cambiar su significado. Un minificador de XML suprime los espacios en blanco entre etiquetas, elimina los comentarios, suprime los saltos de línea y colapsa la indentación para producir una salida compacta en una sola línea. El resultado es una cadena XML que los analizadores leen de forma idéntica a la versión formateada original, produciendo el mismo modelo de datos.

La especificación XML 1.0 (Recomendación W3C, quinta edición) define las reglas de manejo de espacios en blanco en la sección 2.10. Los espacios en blanco entre etiquetas que no tienen valor semántico se denominan "espacios en blanco insignificantes". Los procesadores XML pueden descartarlos. Sin embargo, los espacios en blanco dentro del contenido de texto son significativos por defecto, a menos que el elemento padre declare xml:space="default". Un minificador de XML correcto distingue entre estos dos casos y solo elimina lo que es seguro eliminar.

La minificación es diferente de la compresión. Gzip o Brotli reducen el tamaño en la capa de transporte y requieren descompresión antes del análisis. La minificación reduce el tamaño del documento en bruto, por lo que el XML permanece válido y legible por cualquier analizador sin un paso de descompresión. En la práctica, minificar antes de comprimir ofrece los mejores resultados: primero se eliminan los caracteres redundantes y luego el algoritmo de compresión trabaja sobre una entrada más compacta.

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

¿Por qué usar un minificador de XML?

El XML formateado con indentación y comentarios es ideal para el desarrollo y la revisión de código. Para el almacenamiento, la transmisión y el consumo por máquinas, ese formato adicional añade bytes sin ningún beneficio. Un minificador de XML cierra esa brecha.

Casos de uso del Minificador de XML

Qué elimina la minificación de XML

No todo lo que hay en un documento XML puede eliminarse de forma segura. Esta tabla de referencia muestra cada tipo de contenido eliminable e indica si descartarlo es siempre seguro o está condicionado a tu caso de uso.

Minificación vs Gzip vs Formatos binarios

La minificación, la compresión y la codificación binaria actúan sobre diferentes capas del problema de tamaño. La minificación mantiene la salida como XML válido y legible por humanos. La compresión (gzip, Brotli) reduce aún más el tamaño, pero requiere un paso de descompresión antes del análisis. Los formatos binarios van más lejos, pero ambos extremos de la conexión necesitan un codificador/decodificador compatible — práctico principalmente para sistemas embebidos o servicios empresariales con WSDL intensivo.

Ejemplos de código

Minificar XML mediante programación sigue el mismo patrón en todos los lenguajes: analizar el documento como un árbol, opcionalmente eliminar los nodos de comentarios y luego serializar sin indentación.

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

Preguntas frecuentes