Skip to content

XML Hoja de referencia

Lenguaje de marcado extensible para el intercambio de datos estructurados.

01

Primeros pasos

Estructura del documento XML

Los documentos XML empiezan con una declaración XML. Los elementos deben anidarse y cerrarse correctamente. Los atributos aportan metadatos adicionales. xmlns declara los espacios de nombres XML para evitar conflictos de nombres.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a comment -->
<bookstore xmlns="https://example.com/books">
  <book id="b1" category="fiction">
    <title lang="en">The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
    <price currency="USD">12.99</price>
  </book>
  <book id="b2" category="programming">
    <title lang="en">XML Guide</title>
    <author>John Doe</author>
    <price currency="USD">29.99</price>
  </book>
</bookstore>

Declaración XML

La declaración XML es la primera línea del prólogo. 'version' es obligatoria (1.0 o 1.1). 'encoding' pasa por defecto a UTF-8. 'standalone' indica a los parsers si se necesitan declaraciones DTD externas.

xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<!-- version is required; encoding and standalone are optional -->
<!-- encoding defaults to UTF-8 -->
<!-- standalone="yes" means no external markup declarations -->

<root>
  <child>text</child>
</root>

Comentarios e instrucciones de procesamiento

Los comentarios usan <!-- --> y no pueden anidarse ni contener '--' dentro. Las instrucciones de procesamiento (PIs) como xml-stylesheet pasan información específica de la app al parser. Las PIs usan <?objetivo datos?>.

xml
<?xml version="1.0"?>
<!-- a comment: ignored by the parser, cannot contain -- -->

<?xml-stylesheet type="text/xsl" href="style.xsl"?>

<root>
  <!-- comments can span
       multiple lines -->
  <item>data</item>
</root>

XML bien formado

Bien formado significa: un elemento raíz, anidamiento correcto, todas las etiquetas cerradas, atributos entrecomillados, sin atributos duplicados. Un documento DEBE estar bien formado para ser parseable; la validez (contra un DTD/Esquema) es opcional.

xml
<!-- WELL-FORMED: single root, properly nested, closed -->
<root>
  <a>
    <b>text</b>
  </a>
</root>

<!-- NOT well-formed: two roots, overlapping tags -->
<!-- <a><b></a></b> -->
<!-- <x></x><y></y>   (no single root) -->

<!-- All attributes must be quoted -->
<item id='1' type="x"/>

Prólogo XML y espacios en blanco

El prólogo incluye la declaración XML y un DOCTYPE opcional. xml:space='preserve' indica a los parsers que conserven el espacio en blanco; 'default' permite el manejo normal. El espacio en blanco entre elementos es generalmente insignificante.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root SYSTEM "root.dtd">
<root xml:space="preserve">
  <item>  spaced  text  </item>
  <item xml:space="default">  trimmed  </item>
</root>

Visión general de CDATA

Las secciones CDATA marcan texto que el parser no debe interpretar como marcado. Dentro de CDATA, caracteres como <, > y & no necesitan escape. CDATA no puede anidarse y no puede contener el literal ']]>'.

xml
<?xml version="1.0"?>
<root>
  <code><![CDATA[
    if (a < b && c > d) {
      console.log("no escaping needed: < > & ");
    }
  ]]></code>
</root>
02

Elementos y atributos

Elementos vs atributos

Los atributos encajan con los metadatos (ids, tipos, flags); los elementos, con datos que tienen estructura o valores repetidos. Un atributo aparece una vez por elemento y no puede contener estructura anidada. No hay regla estricta—la consistencia importa más.

xml
<!-- Attributes: metadata/identifiers; Elements: data -->
<person id="p1">
  <name>Alice</name>
  <age>30</age>
</person>

<!-- vs. putting everything in attributes -->
<person id="p1" name="Alice" age="30"/>

<!-- Rule of thumb: use elements for data you display,
     attributes for IDs, types, and metadata -->

Elementos vacíos

Un elemento vacío no tiene contenido. La forma auto-cerrada <etiqueta/> es abreviatura de <etiqueta></etiqueta>. El espacio antes de '/>' es una convención de estilo por legibilidad y compatibilidad con XHTML.

xml
<!-- Three equivalent empty-element forms -->
<br></br>
<br/>
<br />

<!-- empty element with attributes -->
<img src="logo.png" alt="Logo" width="200" height="100"/>

<!-- self-closing with namespace -->
<xlink:link xmlns:xlink="http://www.w3.org/1999/xlink" href="#sec1"/>

Elementos anidados

Los elementos se anidan jerárquicamente y deben cerrarse en orden inverso—no pueden solaparse. El anidamiento expresa la estructura. Los árboles profundamente anidados son válidos pero pueden perjudicar la legibilidad y el rendimiento del parseo.

xml
<library>
  <section name="fiction">
    <book>
      <title>Book A</title>
      <authors>
        <author>Author 1</author>
        <author>Author 2</author>
      </authors>
    </book>
  </section>
</library>

<!-- WRONG: tags must not overlap -->
<!-- <a><b></a></b> -->

Valores y comillas de atributos

Los valores de atributo deben entrecomillarse con comillas simples o dobles. Las comillas dobles dentro de valores con comillas dobles deben escaparse como &quot;. Un atributo puede aparecer solo una vez por elemento—usa elementos hijos para valores repetidos.

xml
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said &quot;hi&quot;"/>
<msg text='She said &apos;hi&apos;'/>

<!-- attribute values MUST be quoted -->
<!-- <item id=q1/>  is NOT well-formed -->

<!-- an attribute can appear at most once per element -->
<point x="1" y="2" z="3"/>

Atributos por defecto y fijos

Las declaraciones de atributos DTD soportan #REQUIRED (debe aparecer), #IMPLIED (opcional), #FIXED (valor constante) y un valor por defecto literal. Un atributo #FIXED debe igualar siempre su valor declarado o el documento es inválido.

xml
<!-- In a DTD, attributes can have defaults -->
<!ATTLIST item
    type    CDATA     "standard"
    status  CDATA     #REQUIRED
    version CDATA     #FIXED "1.0"
    note    CDATA     #IMPLIED>

<item status="active"/>
<!-- 'type' defaults to "standard", 'version' is fixed,
     'note' is optional (#IMPLIED) -->

Reglas de nombrado de elementos

Los nombres de elementos deben empezar por una letra o guion bajo y pueden contener letras, dígitos, guiones, guiones bajos y puntos. Los nombres no pueden empezar por 'xml' (en cualquier mayúscula). XML distingue mayúsculas, así que <Tag> y <tag> difieren.

xml
<!-- Names: start with a letter or underscore,
     continue with letters, digits, hyphens, underscores, dots -->
<my-element>ok</my-element>
<my.element>ok</my.element>
<my_element>ok</my_element>
<_private>ok</_private>
<x-1>ok</x-1>

<!-- NOT allowed: starting with a digit or 'xml', containing spaces -->
<!-- <2way/> -->
<!-- <my element/> -->
<!-- <XmlTag/>  (names are case-sensitive; 'xml' prefix is reserved) -->
03

Espacios de nombres

Espacio de nombres por defecto

Un espacio de nombres por defecto (xmlns=URI) aplica al elemento donde se declara y a cualquier descendiente sin prefijo. Los elementos hijos lo heredan salvo que se anule. Los atributos nunca usan el espacio de nombres por defecto.

xml
<?xml version="1.0"?>
<table xmlns="http://www.w3.org/1999/xhtml">
  <tr>
    <td>Cell content</td>
    <td>More content</td>
  </tr>
</table>
<!-- All elements without a prefix use the default namespace -->

Prefijo de espacio de nombres

Un prefijo de espacio de nombres se declara con xmlns:prefijo=URI y se usa como prefijo:elemento. El prefijo es solo un alias—solo el URI importa para la identidad. Los prefijos distinguen mayúsculas.

xml
<?xml version="1.0"?>
<root xmlns:bk="https://example.com/books"
      xmlns:au="https://example.com/authors">
  <bk:book bk:id="b1">
    <au:author au:name="Jane Doe"/>
    <bk:title>XML Guide</bk:title>
  </bk:book>
</root>

Espacios de nombres múltiples

Un solo documento puede mezclar muchos espacios de nombres. Declara cada prefijo una vez (normalmente en la raíz) y reutilízalo. Declarar un espacio de nombres en un elemento aplica a ese elemento y a sus descendientes.

xml
<?xml version="1.0"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
    <m:GetPrice xsi:type="xsd:string"
                xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>

Ámbito del espacio de nombres

Las declaraciones de espacios de nombres están acotadas al elemento donde aparecen y a sus descendientes. Una redeclaración dentro de un hijo anula el mapeo de prefijo del padre para ese subárbol. El mapeo original se restaura tras cerrarse el hijo.

xml
<?xml version="1.0"?>
<root xmlns:a="http://a.example">
  <a:item>A</a:item>
  <child xmlns:a="http://b.example">
    <!-- here 'a' is REBOUND to the b.example URI -->
    <a:item>B</a:item>
  </child>
  <!-- outside child, 'a' is back to a.example -->
  <a:item>A again</a:item>
</root>

Espacios de nombres comunes

Estos URIs son identificadores conocidos, no URLs que haya que obtener. El espacio de nombres xsi aporta atributos de instancia de esquema (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom y Dublin Core (dc) tienen cada uno URIs estándar.

xml
<!-- Frequently used namespace URIs -->
xmlns:xsi  = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd  = "http://www.w3.org/2001/XMLSchema"
xmlns:xsl  = "http://www.w3.org/1999/XSL/Transform"
xmlns:svg  = "http://www.w3.org/2000/svg"
xmlns:html = "http://www.w3.org/1999/xhtml"
xmlns:soap = "http://schemas.xmlsoap.org/soap/envelope/"
xmlns:atom = "http://www.w3.org/2005/Atom"
xmlns:dc   = "http://purl.org/dc/elements/1.1/"

Espacio de nombres objetivo en XSD

El targetNamespace de un esquema es el espacio de nombres de los elementos que define. elementFormDefault='qualified' significa que los elementos declarados localmente están en el espacio de nombres objetivo. El prefijo tns es una convención de 'este espacio de nombres'.

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/orders"
           xmlns:tns="https://example.com/orders"
           elementFormDefault="qualified">
  <xs:element name="order" type="tns:OrderType"/>
  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="item" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:schema>
04

CDATA y entidades

Entidades predefinidas

XML predefine cinco entidades: &lt; (<), &gt; (>), &amp; (&), &apos; ('), &quot; ("). & debe escaparse SIEMPRE (incluso en texto sin CDATA); < debe escaparse salvo como inicio de etiqueta; las comillas importan principalmente en los atributos.

xml
<?xml version="1.0"?>
<root>
  <lt>less than: &lt;</lt>
  <gt>greater than: &gt;</gt>
  <amp>ampersand: &amp;</amp>
  <apos>apostrophe: &apos;</apos>
  <quot>quote: &quot;</quot>
  <!-- &lt; &gt; &amp; &apos; &quot; are the 5 built-in entities -->
</root>

Referencias de caracteres

Las referencias de caracteres usan un punto de código Unicode: &#169; (decimal) o &#xA9; (hex) para ©. Funcionan en el texto de elementos y en los valores de atributos y no se ven afectadas por la codificación. Pueden representar cualquier carácter Unicode.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <decimal>&#169; 2024 Company</decimal>
  <hex>&#xA9; 2024 Company</hex>
  <euro>Price: &#x20AC;10</euro>
  <emoji>Smile: &#x1F600;</emoji>
</root>
<!-- &#NNN;  decimal code point -->
<!-- &#xHHH; hexadecimal code point -->

Secciones CDATA

Las secciones CDATA te permiten incluir <, > y & sin escapar—útil para código y marcado. CDATA no puede contener ']]>' literalmente; para incrustarlo, divide la sección como se muestra. CDATA son datos de caracteres, no se parsean como elementos.

xml
<?xml version="1.0"?>
<root>
  <script><![CDATA[
    function check(a, b) {
      if (a < b && b > 0) {
        return a & b;
      }
    }
  ]]></script>
  <!-- to include ]]> inside CDATA, split it -->
  <data><![CDATA[foo]]]]><![CDATA[>bar]]></data>
</root>

Entidades personalizadas (DTD)

Las entidades internas se declaran en un DTD y se expanden dondequiera que se referencien. Actúan como macros de texto y pueden referenciar otras entidades. Útil para boilerplate repetido. Cuidado: las entidades externas/generales pueden ser un riesgo de seguridad XXE.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY company "Acme Corp.">
  <!ENTITY version "2.0">
  <!ENTITY copyright "Copyright © 2024 &company;">
]>
<root>
  <product>&company; Toolkit v&version;</product>
  <footer>&copyright;</footer>
</root>
<!-- Entities are expanded during parsing -->

Escapar en atributos

Dentro de los valores de atributo debes escapar & como &amp;, y escapar el carácter de comilla usado para delimitar el valor (&quot; o &apos;). < también debería escaparse. Los saltos de línea y tabulaciones en los atributos se normalizan a espacios por el parser.

xml
<?xml version="1.0"?>
<root>
  <link url="https://example.com?a=1&amp;b=2"/>
  <msg text="Say &quot;hello&quot; &amp; smile"/>
  <path value='C:\Users\name'/>
  <data value="&lt;tagged&gt;"/>
</root>

Entidades de parámetro

Las entidades de parámetro (declaradas con %) se usan solo dentro de los DTDs para construir modelos de contenido reutilizables. Se referencian como %nombre; (con punto y coma). Las entidades generales (&nombre;) se usan en el contenido del documento.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY % inline " (#PCDATA | em | strong)* ">
  <!ELEMENT p %inline;>
  <!ELEMENT em %inline;>
  <!ELEMENT strong %inline;>
  <!ELEMENT root (p)*>
]>
<root>
  <p>Hello <em>world</em> and <strong>XML</strong>.</p>
</root>
05

DTD (Document Type Definition)

DTD interno

Un DTD interno se declara en línea en el DOCTYPE entre corchetes. Define la estructura: qué elementos existen, sus modelos de contenido y atributos. Los DTD internos son autosuficientes pero solo aplican a ese documento.

xml
<?xml version="1.0"?>
<!DOCTYPE note [
  <!ELEMENT note (to, from, heading, body)>
  <!ELEMENT to (#PCDATA)>
  <!ELEMENT from (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body (#PCDATA)>
]>
<note>
  <to>Alice</to>
  <from>Bob</from>
  <heading>Reminder</heading>
  <body>Don't forget the meeting</body>
</note>

DTD externo

Un DTD externo vive en un archivo .dtd separado referenciado por SYSTEM (privado) o PUBLIC (identificador público + URI). Los DTD externos permiten que muchos documentos compartan una definición. SYSTEM 'archivo.dtd' es la forma más común.

xml
<!-- File: note.dtd -->
<!ELEMENT note (to, from, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT body (#PCDATA)>

<!-- File: note.xml -->
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
  <to>Alice</to>
  <from>Bob</from>
  <body>Hello</body>
</note>

Declaraciones de elementos

Los modelos de contenido usan , (secuencia), | (elección), ? (0-1), * (0+), + (1+). #PCDATA es texto; el contenido mixto permite texto intercalado con elementos. EMPTY significa sin contenido; ANY desactiva la comprobación (evítalo en producción).

xml
<!ELEMENT root (child1, child2*)>
<!-- content model operators -->
<!ELEMENT list (item+)>            <!-- one or more item -->
<!ELEMENT opt (item?)>             <!-- zero or one item   -->
<!ELEMENT any (item1 | item2)*>    <!-- choice, any number  -->
<!ELEMENT text (#PCDATA)>          <!-- parsed character data -->
<!ELEMENT mixed (#PCDATA | em)*>   <!-- mixed content -->
<!ELEMENT empty EMPTY>             <!-- no content -->
<!ELEMENT any ANY>                 <!-- any content -->

Declaraciones de atributos

ATTLIST declara el tipo y valor por defecto de un atributo. ID es un identificador único; IDREF/IDREFS referencian IDs (para enlaces cruzados). NMTOKEN es un token de nombre. Los tipos enumerados listan los valores permitidos. Valores por defecto: #REQUIRED, #IMPLIED, #FIXED o un literal.

xml
<!ATTLIST book
    id      ID         #REQUIRED
    category CDATA     #IMPLIED
    lang    NMTOKEN    "en"
    status  (draft|final) "draft"
    version CDATA      #FIXED "1.0">

<!-- Types: CDATA, ID, IDREF, IDREFS, NMTOKEN, NMTOKENS,
     NOTATION, enumerated (a|b|c) -->
<!ATTLIST link ref IDREF #REQUIRED>

Declaraciones de entidades

Las entidades generales (&nombre;) se expanden en el contenido; las de parámetro (%nombre;) en el DTD. Las entidades externas parseadas incluyen otro XML; las no parseadas (con NDATA) apuntan a datos no XML referenciados vía NOTATION. Las entidades externas pueden causar inyección XXE.

xml
<!DOCTYPE root [
  <!-- internal general entity -->
  <!ENTITY name "Alice">
  <!-- external parsed entity -->
  <!ENTITY chap1 SYSTEM "chapter1.xml">
  <!-- unparsed entity (binary, e.g. image) -->
  <!ENTITY logo SYSTEM "logo.png" NDATA image>
  <!-- notation declaration for unparsed entities -->
  <!NOTATION image SYSTEM "image/png">
  <!-- parameter entity (DTD-only) -->
  <!ENTITY % block "(p | list)+">
]>
<root>&name;</root>

Validación DTD

La validación comprueba que un documento coincida con su DTD (orden de elementos, atributos permitidos, unicidad de IDs). Los parsers DOM estándar como minidom NO validan por defecto—usa lxml (Python), xmllint (línea de comandos) o un parser validador.

xml
<?xml version="1.0"?>
<!DOCTYPE root SYSTEM "schema.dtd">
<root>
  <item id="x1">valid</item>
</root>

<!-- Validate with Python: -->
<!-- import xml.dom.minidom as m
dom = m.parse("file.xml")
# minidom does NOT validate; use lxml: -->
<!-- from lxml import etree
dtd = etree.DTD("schema.dtd")
tree = etree.parse("file.xml")
print(dtd.validate(tree)) -->
06

XML Schema (XSD)

Estructura del esquema

Un XSD es en sí mismo un documento XML. La raíz <schema> declara el espacio de nombres XSD y un espacio de nombres objetivo para los elementos que define. elementFormDefault='qualified' pone los elementos locales en el espacio de nombres objetivo.

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/order"
           xmlns:tns="https://example.com/order"
           elementFormDefault="qualified">

  <xs:element name="order" type="tns:OrderType"/>

  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="customer" type="xs:string"/>
      <xs:element name="total" type="xs:decimal"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:ID" use="required"/>
  </xs:complexType>
</xs:schema>

Tipos simples

Un simpleType restringe un tipo base con facetas (pattern, minInclusive, enumeration, length, etc.). Los tipos simples solo tienen contenido de texto y atributos—sin elementos hijos. Son reutilizables a través del esquema.

xml
<xs:simpleType name="emailType">
  <xs:restriction base="xs:string">
    <xs:pattern value="[^@]+@[^@]+.[^@]+"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="ageType">
  <xs:restriction base="xs:integer">
    <xs:minInclusive value="0"/>
    <xs:maxInclusive value="120"/>
  </xs:restriction>
</xs:simpleType>

<xs:element name="email" type="tns:emailType"/>
<xs:element name="age" type="tns:ageType"/>

Tipos complejos

Un complexType puede contener elementos hijos y atributos. sequence impone el orden; choice permite uno de varios; all permite cualquier orden (cada uno como máximo una vez). Los compositores pueden anidarse para expresar estructuras ricas.

xml
<xs:complexType name="AddressType">
  <xs:sequence>
    <xs:element name="street" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:string" default="US"/>
</xs:complexType>

<!-- Content model indicators: sequence, choice, all -->
<xs:complexType name="ContactType">
  <xs:choice>
    <xs:element name="phone" type="xs:string"/>
    <xs:element name="email" type="xs:string"/>
  </xs:choice>
</xs:complexType>

Tipos integrados

XSD aporta una rica jerarquía de tipos: cadenas, números (integer, decimal, float), fechas/horas, boolean, anyURI, ID/IDREF y QName. Cada uno soporta facetas como length, pattern y enumeration para restringirlo más.

xml
<!-- Common XSD built-in types -->
<xs:element name="count"  type="xs:integer"/>
<xs:element name="price"  type="xs:decimal"/>
<xs:element name="flag"   type="xs:boolean"/>
<xs:element name="name"   type="xs:string"/>
<xs:element name="date"   type="xs:date"/>        <!-- 2024-01-15 -->
<xs:element name="time"   type="xs:time"/>        <!-- 13:45:00 -->
<xs:element name="dt"     type="xs:dateTime"/>    <!-- 2024-01-15T13:45:00 -->
<xs:element name="id"     type="xs:ID"/>
<xs:element name="ref"    type="xs:IDREF"/>
<xs:element name="uri"    type="xs:anyURI"/>

Restricciones (facetas)

Las facetas acotan los tipos simples: enumeration (valores permitidos), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits y whiteSpace (preserve/replace/collapse).

xml
<xs:simpleType name="ColorType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="red"/>
    <xs:enumeration value="green"/>
    <xs:enumeration value="blue"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="PasswordType">
  <xs:restriction base="xs:string">
    <xs:minLength value="8"/>
    <xs:maxLength value="32"/>
    <xs:pattern value="[A-Za-z0-9!@#]+"/>
  </xs:restriction>
</xs:simpleType>

Elementos y atributos en XSD

minOccurs/maxOccurs controlan la cardinalidad (1 por defecto); maxOccurs='unbounded' permite cualquier número. El 'use' del atributo es required/optional/prohibited, con un valor por defecto o fijo opcional. Los complexTypes anónimos incrustan la definición en línea.

xml
<xs:element name="product">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="name" type="xs:string"
                  minOccurs="1" maxOccurs="1"/>
      <xs:element name="tag" type="xs:string"
                  minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="sku" type="xs:string" use="required"/>
    <xs:attribute name="weight" type="xs:decimal" use="optional"
                  default="0.0"/>
  </xs:complexType>
</xs:element>
07

XPath

Expresiones de ruta

XPath usa expresiones tipo ruta. '/' selecciona desde la raíz; '//' selecciona descendientes a cualquier profundidad. '*' es un comodín para cualquier elemento; '@' selecciona atributos. Una expresión que empieza por '/' es absoluta.

xml
<!-- Sample: <bookstore><book><title>..</title></book></bookstore> -->

/bookstore/book/title       <!-- absolute path -->
bookstore/book/title        <!-- relative path -->
//title                     <!-- any title, anywhere -->
/bookstore//title           <!-- title anywhere under bookstore -->
bookstore/*                 <!-- all children of bookstore -->
//@lang                     <!-- all lang attributes -->
//@*                        <!-- all attributes -->

Predicados

Los predicados en [ ] filtran un conjunto de nodos. La indexación empieza en 1. last() y position() se refieren a la posición del nodo en su contexto. Los predicados pueden probar el texto del elemento, los atributos (@nombre) o valores computados.

xml
//book[1]                  <!-- first book -->
//book[last()]            <!-- last book -->
//book[position() <= 3]   <!-- first three books -->
//book[price > 25]        <!-- books with price > 25 -->
//book[@category='web']   <!-- books in the web category -->
//book[author='Smith']    <!-- books authored by Smith -->
//book[@lang][2]          <!-- 2nd book that has a lang attr -->

Ejes

Los ejes definen direcciones de navegación: child (por defecto), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). La mayoría tiene formas abreviadas usadas en la práctica.

xml
child::book            <!-- default axis: children named book -->
descendant::title      <!-- all title descendants -->
parent::*              <!-- the parent element (shorthand: ..) -->
ancestor::section      <!-- all section ancestors -->
following-sibling::p   <!-- p elements after this one -->
preceding::item        <!-- items before this in document order -->
attribute::id          <!-- the id attribute (shorthand: @id) -->
self::node()           <!-- the current node (shorthand: .) -->

Funciones

XPath 1.0 tiene funciones integradas: count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round y más. XPath 2.0+ expande vastamente la librería de funciones y añade tipado.

xml
count(//book)                  <!-- number of book elements -->
string-length(//title)        <!-- length of first title's text -->
contains(//name, 'Ali')       <!-- true if name contains 'Ali' -->
starts-with(@id, 'b')         <!-- true if id starts with 'b' -->
normalize-space(//summary)    <!-- collapse whitespace -->
name(//*[1])                  <!-- name of the first element -->
concat(/a, /b)                <!-- concatenate strings -->
sum(//price)                  <!-- sum of all price values -->

Operadores

XPath usa = para la igualdad (= único, no ==), y los operadores 'and'/'or' para la lógica (no && / ||). 'div' es la división y 'mod' el módulo, ya que '/' está reservado para las rutas. '|' computa la unión de conjuntos de nodos.

xml
<!-- Comparison: =, !=, <, >, <=, >= -->
//book[price = 29.99]
//book[price < 20]

<!-- Logical: and, or -->
//book[price > 10 and price < 30]
//book[@cat='a' or @cat='b']

<!-- Arithmetic: + - * div mod -->
//item[price * quantity > 100]
5 div 2        <!-- 2.5 -->
5 mod 2        <!-- 1 -->

<!-- Union: | -->
//book | //magazine

Ejemplos de XPath

Estos patrones combinan rutas, predicados y funciones para consultas reales. text() selecciona el nodo de texto; min() exige XPath 2.0+. El comodín //* con un predicado es la forma común de hallar elementos por atributo a través del árbol completo.

xml
<!-- Select all book titles priced over 20 -->
//book[price > 20]/title/text()

<!-- The category of the cheapest book -->
//book[price = min(//book/price)]/@category

<!-- Authors of books in the 'programming' category -->
//book[@category='programming']/author

<!-- Every 2nd item in each list -->
//list/item[position() mod 2 = 0]

<!-- Elements with a specific attribute value -->
//*[@lang='fr']
08

Transformaciones XSLT

Transformación básica

Una hoja de estilo XSLT es XML. Las plantillas emparejan nodos con XPath; apply-templates procesa recursivamente los nodos seleccionados. value-of extrae texto. La plantilla match='/' corre primero, sobre la raíz del documento.

xml
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
    <html>
      <body>
        <h2>Book List</h2>
        <xsl:apply-templates select="bookstore/book"/>
      </body>
    </html>
  </xsl:template>

  <xsl:template match="book">
    <p><xsl:value-of select="title"/> - <xsl:value-of select="price"/></p>
  </xsl:template>
</xsl:stylesheet>

xsl:template y apply-templates

Las plantillas match se disparan cuando el procesador visita los nodos coincidentes; las plantillas con nombre se llaman explícitamente con call-template. apply-templates sin select procesa cada hijo, habilitando transformaciones recursivas guiadas por reglas.

xml
<xsl:template match="book">
  <div class="book">
    <xsl:apply-templates select="title"/>
    <xsl:apply-templates select="author"/>
  </div>
</xsl:template>

<xsl:template match="title">
  <h3><xsl:apply-templates/></h3>
</xsl:template>

<!-- named template (like a function) -->
<xsl:template name="divider">
  <hr/>
</xsl:template>

xsl:value-of y xsl:for-each

xsl:for-each itera un conjunto de nodos, cambiando el nodo de contexto. Suele ser más simple que las plantillas para salida plana, pero el abuso hace las hojas de estilo procedimentales. Prefiere las plantillas y apply-templates para estructuras recursivas.

xml
<xsl:template match="/">
  <ul>
    <xsl:for-each select="bookstore/book">
      <li>
        <xsl:value-of select="title"/>
        (<xsl:value-of select="@category"/>)
      </li>
    </xsl:for-each>
  </ul>
</xsl:template>

<!-- value-of outputs the string value of an expression -->

xsl:if y xsl:choose

xsl:if no tiene else—usa xsl:choose para las ramas múltiples. La expresión 'test' sigue las reglas booleanas de XPath: un conjunto de nodos no vacío es verdadero, uno vacío es falso, los números distintos de cero son verdaderos.

xml
<xsl:for-each select="bookstore/book">
  <xsl:if test="price > 25">
    <premium><xsl:value-of select="title"/></premium>
  </xsl:if>

  <xsl:choose>
    <xsl:when test="@category='fiction'">F</xsl:when>
    <xsl:when test="@category='programming'">P</xsl:when>
    <xsl:otherwise>?</xsl:otherwise>
  </xsl:choose>
</xsl:for-each>

<!-- test uses XPath; non-empty node-sets and non-zero numbers are true -->

xsl:sort y xsl:variable

xsl:sort reordena el conjunto de nodos actual por una o más claves; data-type es 'text' o 'number'. Las variables (xsl:variable) son inmutables y tienen ámbito. Recuerda escapar < como &lt; dentro de los valores de atributo en el XML de la hoja de estilo.

xml
<xsl:variable name="max-price" select="50"/>

<xsl:for-each select="bookstore/book[price &lt; $max-price]">
  <xsl:sort select="price" data-type="number" order="descending"/>
  <xsl:sort select="title" order="ascending"/>
  <p>
    <xsl:value-of select="title"/>: <xsl:value-of select="price"/>
  </p>
</xsl:for-each>

<!-- Note: in XSLT, < must be written &lt; inside test attributes -->

apply-templates y modes

Los modes permiten que un conjunto de nodos fuente se procese de formas distintas (por ejemplo, una tabla de contenido frente a las entradas completas). El atributo mode tanto en la plantilla como en apply-templates debe coincidir. Sin mode, solo aplican las plantillas sin modo.

xml
<!-- A template can have a 'mode' for different outputs -->
<xsl:template match="book" mode="list">
  <li><xsl:value-of select="title"/></li>
</xsl:template>

<xsl:template match="book" mode="detail">
  <div><h3><xsl:value-of select="title"/></h3>
       <p><xsl:value-of select="author"/></p></div>
</xsl:template>

<!-- Invoke a specific mode -->
<xsl:apply-templates select="bookstore/book" mode="list"/>
<xsl:apply-templates select="bookstore/book" mode="detail"/>
09

XQuery

Expresiones FLWOR

FLWOR es la construcción central de XQuery: for vincula variables a ítems de secuencia, let vincula valores computados, where filtra, order by ordena y return da forma a la salida. Se parece al SELECT-FROM-WHERE de SQL.

xml
for $b in /bookstore/book
let $discount := $b/price * 0.9
where $b/price > 20
order by $b/price descending
return
  <book>
    <title>{ $b/title/text() }</title>
    <salePrice>{ $discount }</salePrice>
  </book>

<!-- FLWOR = For, Let, Where, Order by, Return -->

Expresiones de ruta

XQuery incrusta XPath directamente. doc('archivo.xml') carga un documento; collection('uri') consulta varios documentos. Las expresiones de ruta devuelven secuencias de nodos, que las expresiones FLWOR pueden iterar.

xml
(: XQuery uses XPath for navigation :)
/bookstore/book/title/text()
/bookstore/book[@category='web']
//author[contains(., 'Smith')]

(: Use doc() to open an external document :)
doc('catalog.xml')//book[price < 30]

(: collection() queries a set of documents :)
collection('/db/books')//title

Predicados y joins

Varias cláusulas 'for' forman un join (como el JOIN de SQL). XQuery hace los joins iterando combinaciones y filtrando con where. Para datasets grandes, los joins explícitos vía predicados o claves son más eficientes que los bucles anidados.

xml
(: Join books to authors by id :)
for $b in doc('books.xml')//book
for $a in doc('authors.xml')//author
where $b/@author-id = $a/@id
return
  <entry>
    <title>{ $b/title/text() }</title>
    <author>{ $a/name/text() }</author>
  </entry>

(: Equivalent join with a predicate :)
for $b in doc('books.xml')//book
return
  <entry>{ $b/title, $b/@author-id }</entry>

Condicional y cuantificado

XQuery tiene if-then-else (el else es obligatorio), expresiones cuantificadas (some/every ... satisfies) y typeswitch para ramificar según el tipo de nodo. Las condiciones usan la semántica booleana estilo XPath.

xml
(: if-then-else :)
for $b in //book
return
  if ($b/price > 30) then <expensive>{ $b/title }</expensive>
  else <cheap>{ $b/title }</cheap>

(: quantified expressions :)
some $a in //author satisfies contains($a, 'Smith')
every $p in //price satisfies $p > 0

(: typeswitch for type-based dispatch :)
typeswitch($node)
  case element(book) return "book"
  case element(author) return "author"
  default return "other"

Funciones

XQuery reutiliza las funciones de XPath y añade muchas (string-join, distinct-values, avg, min, max). Las funciones de usuario se declaran en el módulo con tipos de parámetro y retorno, en el espacio de nombres local: por convención.

xml
(: Built-in functions :)
concat('a', 'b', 'c')
string-join(//title, ', ')
count(//book)
distinct-values(//book/@category)
avg(//book/price)
max(//book/price)

(: User-defined function :)
declare function local:discount($price as xs:decimal)
  as xs:decimal {
  $price * 0.9
};

local:discount(29.99)

Construir XML

XQuery construye XML con constructores directos (etiquetas literales con { } para expresiones incrustadas) o computados (element nombre { ... }). Las llaves evalúan las expresiones encerradas; los atributos pueden incrustar valores en línea.

xml
(: Direct element construction :)
<result>
  <count>{ count(//book) }</count>
  <books>
    { for $b in //book return <book title="{ $b/title/text() }"/> }
  </books>
</result>

(: Computed constructors :)
element result {
  attribute total { count(//book) },
  for $b in //book
  return element book { $b/title/text() }
}

(: Enclosed expressions use { } to embed values -->
10

Parseo DOM

Cargar XML (JavaScript)

DOMParser convierte una cadena XML en un árbol DOM en el navegador; los errores de parseo aparecen como un elemento <parsererror> en lugar de una excepción. Node.js no tiene DOM XML integrado—usa xmldom, @xmldom/xmldom o un parser en streaming.

xml
// Browser: parse an XML string
const parser = new DOMParser();
const doc = parser.parseFromString(xmlString, "application/xml");

const errorNode = doc.querySelector("parsererror");
if (errorNode) {
  console.error("Parse error:", errorNode.textContent);
}

const books = doc.getElementsByTagName("book");
for (const book of books) {
  console.log(book.getAttribute("id"));
}

// Node.js: use xmldom or fast-xml-parser instead

Recorrido DOM

La API DOM expone documentElement, children, childNodes y nextSibling para el recorrido. nodeType 1 es un elemento, 3 es texto, 8 un comentario. document.evaluate corre XPath en los navegadores (Node necesita librerías xpath).

xml
// JavaScript DOM API (also works for XML documents)
const root = doc.documentElement;        // <bookstore>
const firstBook = root.children[0];      // first <book>
const titles = doc.getElementsByTagName("title");

// walk children
let node = root.firstChild;
while (node) {
  if (node.nodeType === 1) {             // Element node
    console.log(node.tagName);
  }
  node = node.nextSibling;
}

// XPath against the DOM
const it = doc.evaluate("//book[@id='b1']", doc, null,
                        XPathResult.ANY_TYPE, null);
const found = it.iterateNext();

Modificar el DOM

createElement/setAttribute/appendChild construyen y adjuntan nodos; textContent fija el texto. XMLSerializer convierte un DOM de vuelta a cadena. El DOM está vivo—las mutaciones se reflejan de inmediato en cualquier referencia.

xml
const book = doc.createElement("book");
book.setAttribute("id", "b3");

const title = doc.createElement("title");
title.textContent = "New Book";
book.appendChild(title);

root.appendChild(book);                  // add to tree

// change an existing element
const price = doc.querySelector("book:nth-child(2) price");
price.textContent = "19.99";
price.setAttribute("currency", "EUR");

// serialize back to a string
const xml = new XMLSerializer().serializeToString(doc);

Crear elementos

minidom te permite construir un documento desde cero: createDocument para la raíz, createElement/setAttribute/createTextNode para el contenido, appendChild para enlazar. toprettyxml serializa con sangría. minidom es simple pero lento para árboles grandes.

xml
// Python: xml.dom.minidom
from xml.dom import minidom

impl = minidom.getDOMImplementation()
doc = impl.createDocument(None, "root", None)
root = doc.documentElement

item = doc.createElement("item")
item.setAttribute("id", "1")
item.appendChild(doc.createTextNode("Hello"))
root.appendChild(item)

print(doc.toprettyxml(encoding="UTF-8").decode())

Parseo DOM en Java

El DOM de JAXP en Java carga el documento completo en memoria vía DocumentBuilder. setNamespaceAware(true) conserva los prefijos de espacios de nombres. El DOM es cómodo para acceso aleatorio pero pesado en memoria para archivos grandes—prefiere entonces StAX/SAX.

xml
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;

DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setNamespaceAware(true);
Document doc = f.newDocumentBuilder().parse(new File("data.xml"));

Element root = doc.getDocumentElement();
NodeList books = root.getElementsByTagName("book");
for (int i = 0; i < books.getLength(); i++) {
  Element b = (Element) books.item(i);
  String id = b.getAttribute("id");
  String title = b.getElementsByTagName("title")
                      .item(0).getTextContent();
  System.out.println(id + ": " + title);
}

lxml (Python)

lxml es un binding de Python rápido y rico en características para libxml2. Soporta XPath completo, XSLT, validación (DTD/XSD/RelaxNG) y parseo incremental. Su ElementPath (find/findall) es un subconjunto de XPath; usa xpath() para el XPath completo.

xml
from lxml import etree

# parse and validate against a schema
tree = etree.parse("data.xml")
root = tree.getroot()

# XPath with namespaces
ns = {"bk": "https://example.com/books"}
for book in root.xpath("//bk:book", namespaces=ns):
    print(book.get("id"), book.find("bk:title", namespaces=ns).text)

# build an element tree
root = etree.Element("root")
child = etree.SubElement(root, "item", id="1")
child.text = "Hello"
print(etree.tostring(root, pretty_print=True, encoding="unicode"))
11

Parseo SAX

Manejador SAX (Python)

SAX es guiado por eventos y en streaming: el parser llama a startElement, characters y endElement a medida que lee, sin construir nunca un árbol completo. Es eficiente en memoria para archivos enormes. Debes rastrear el estado (por ejemplo, el elemento actual) tú mismo.

xml
import xml.sax

class BookHandler(xml.sax.ContentHandler):
    def startElement(self, name, attrs):
        if name == "book":
            print("Book id:", attrs.getValue("id"))
        self.current = name

    def characters(self, content):
        if self.current == "title":
            print("Title:", content.strip())

    def endElement(self, name):
        self.current = None

xml.sax.parse("books.xml", BookHandler())

Funciones de evento SAX

Los callbacks de ContentHandler marcan los límites del documento y de los elementos. characters() puede dividir un único nodo de texto en varias llamadas—acumúlalo en un búfer. startPrefixMapping/endPrefixMapping reportan las declaraciones de espacios de nombres.

xml
class Handler(xml.sax.ContentHandler):
    def startDocument(self):
        print("parsing started")

    def endDocument(self):
        print("parsing done")

    def startElement(self, name, attrs):
        # attrs: get via attrs.getValue('id') or attrs['id']
        pass

    def endElement(self, name):
        pass

    def characters(self, text):
        # may be called multiple times for one text node
        pass

    def startPrefixMapping(self, prefix, uri):
        print("namespace:", prefix, uri)

startElement / endElement

Rastrear una ruta de elementos (una pila) es la forma estándar de saber tu ubicación durante el streaming. Pon en búfer la salida de characters y vacíala en endElement, porque characters puede dispararse más de una vez por nodo de texto.

xml
class Handler(xml.sax.ContentHandler):
    def __init__(self):
        self.path = []
        self.text = []

    def startElement(self, name, attrs):
        self.path.append(name)
        self.text = []
        if "id" in attrs:
            print("/".join(self.path), "id =", attrs["id"])

    def endElement(self, name):
        if self.path[-1] == "title":
            print("title:", "".join(self.text).strip())
        self.path.pop()

    def characters(self, content):
        self.text.append(content)

Parser SAX de Java

El SAX de Java hereda de DefaultHandler. startElement recibe el URI del espacio de nombres, el nombre local, el nombre cualificado y un objeto Attributes. characters(ch, start, len) aporta una rebanada de chars—ponla en búfer porque un nodo de texto puede abarcar varias llamadas.

xml
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.*;
import javax.xml.parsers.*;

class BookHandler extends DefaultHandler {
    private StringBuilder buf = new StringBuilder();

    public void startElement(String uri, String local,
                             String qName, Attributes attrs) {
        buf.setLength(0);
        if ("book".equals(qName))
            System.out.println("id=" + attrs.getValue("id"));
    }

    public void characters(char[] ch, int start, int len) {
        buf.append(ch, start, len);
    }

    public void endElement(String uri, String local, String qName) {
        if ("title".equals(qName))
            System.out.println("title=" + buf);
    }
}
// SAXParserFactory.newInstance().newSAXParser().parse(file, new BookHandler());

SAX vs DOM

SAX transmite eventos con memoria constante, ideal para archivos enormes y extracción de una pasada. DOM carga el árbol entero, habilitando XPath y mutación aleatoria pero usando memoria proporcional al tamaño del archivo. Elige según el patrón de acceso y el tamaño del archivo.

xml
<!-- SAX: event-driven, streaming, low memory
     DOM:  full tree in memory, random access

     SAX is best for:
       - large files that won't fit in memory
       - read-only filtering / extraction
       - simple state machines over the document

     DOM is best for:
       - random access to many parts of the tree
       - repeated queries / XPath
       - editing and re-serializing -->

<!-- Memory: SAX ~ O(1); DOM ~ O(file size) -->
<!-- Speed:  SAX often faster for one-pass scans -->

Manejo de errores (SAX)

Un ErrorHandler recibe advertencias, errores recuperables y errores fatales. Por defecto, los errores fatales lanzan una excepción y detienen el parseo. Implementar error() te permite registrar problemas de validación no fatales sin abortar el parseo completo.

xml
import xml.sax

class Handler(xml.sax.ContentHandler):
    pass

# ErrorHandler: warning, error, fatalError
class ErrHandler(xml.sax.ErrorHandler):
    def error(self, exception):
        print("ERROR:", exception)
    def fatalError(self, exception):
        print("FATAL:", exception)
        raise exception
    def warning(self, exception):
        print("WARN:", exception)

parser = xml.sax.make_parser()
parser.setContentHandler(Handler())
parser.setErrorHandler(ErrHandler())
parser.parse("data.xml")
12

StAX (parseo por extracción)

API cursor de StAX

StAX es un parser de extracción (pull): tu código extrae el siguiente evento con next(), así que tú controlas el bucle. La API cursor (XMLStreamReader) avanza por los eventos uno a uno. Es más rápido y de menor memoria que el DOM, y más flexible que el modelo push de SAX.

xml
import javax.xml.stream.*;
import java.io.*;

XMLInputFactory factory = XMLInputFactory.newInstance();
// defend against XXE
factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);

XMLStreamReader r = factory.createXMLStreamReader(new FileInputStream("data.xml"));
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT) {
        System.out.println("start: " + r.getLocalName());
    } else if (event == XMLStreamConstants.END_ELEMENT) {
        System.out.println("end: " + r.getLocalName());
    }
}
r.close();

Eventos de XMLStreamReader

Los tipos de evento incluyen START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION y START/END_DOCUMENT. getText() devuelve el texto actual; isWhiteSpace() filtra la sangría. El cursor avanza un evento por llamada a next().

xml
XMLStreamReader r = factory.createXMLStreamReader(in);
while (r.hasNext()) {
    switch (r.next()) {
        case XMLStreamConstants.START_ELEMENT:
            // r.getLocalName(), r.getAttributeValue(i), r.getNamespaceURI()
            break;
        case XMLStreamConstants.END_ELEMENT:
            break;
        case XMLStreamConstants.CHARACTERS:
            if (!r.isWhiteSpace()) {
                String text = r.getText();
            }
            break;
        case XMLStreamConstants.START_DOCUMENT:
            break;
        case XMLStreamConstants.END_DOCUMENT:
            break;
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
            break;
    }
}

Leer elementos y atributos

getAttributeValue(namespaceURI, localName) lee atributos por nombre (pasa null para sin espacio de nombres). getElementText() es una conveniencia que lee el texto de un elemento de solo texto y avanza más allá de su END_ELEMENT—más limpio que poner los caracteres en búfer tú mismo.

xml
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT
            && "book".equals(r.getLocalName())) {
        String id = r.getAttributeValue(null, "id");
        String category = r.getAttributeValue(null, "category");
        System.out.println("Book " + id + " (" + category + ")");
    }
    if (event == XMLStreamConstants.START_ELEMENT
            && "title".equals(r.getLocalName())) {
        String title = r.getElementText();   // consumes until END_ELEMENT
        System.out.println("Title: " + title);
    }
}

Escritor StAX

XMLStreamWriter construye XML secuencialmente. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters y writeNamespace deben equilibrarse. Haz flush/close al final para garantizar que la salida está completa.

xml
XMLOutputFactory out = XMLOutputFactory.newInstance();
XMLStreamWriter w = out.createXMLStreamWriter(System.out, "UTF-8");

w.writeStartDocument("UTF-8", "1.0");
w.writeStartElement("books");
w.writeNamespace("bk", "https://example.com/books");

w.writeStartElement("bk", "book", "https://example.com/books");
w.writeAttribute("id", "b1");
w.writeStartElement("bk", "title", "https://example.com/books");
w.writeCharacters("XML Guide");
w.writeEndElement();   // title
w.writeEndElement();   // book

w.writeEndElement();   // books
w.writeEndDocument();
w.close();

StAX vs SAX

SAX empuja eventos a tu manejador; StAX te deja extraer eventos bajo demanda. El modelo pull de StAX hace más fácil saltarse subárboles y gestionar el estado, y añade una API de escritor. Ambos evitan construir un árbol DOM completo, así que encajan con documentos grandes.

xml
<!-- StAX: PULL model  (client calls next())
     SAX:  PUSH model  (parser calls your handlers)

     StAX advantages:
       - client controls parsing (easy to skip sections)
       - simpler state management for many tasks
       - supports both reading and writing
       - can pause/resume naturally

     SAX advantages:
       - slightly lower overhead in pure streaming
       - mature, widely available
       - filters/chains via XMLFilter

     Both are streaming and memory-efficient. -->

Event reader (API iterador)

La API iterador (XMLEventReader) devuelve objetos XMLEvent que puedes inspeccionar y consumir. Es más orientada a objetos que la API cursor y más fácil para filtrar o dividir, pero ligeramente más pesada por la asignación de objetos de evento.

xml
import javax.xml.stream.*;
import javax.xml.stream.events.*;

XMLEventReader reader = XMLInputFactory.newInstance()
        .createXMLEventReader(in);

while (reader.hasNext()) {
    XMLEvent e = reader.peek();              // look without consuming
    if (e.isStartElement()) {
        StartElement se = e.asStartElement();
        System.out.println(se.getName());
    }
    XMLEvent consumed = reader.nextEvent();   // consume it
    if (consumed.isEndElement()) {
        System.out.println("closed");
    }
}
reader.close();
13

Conversión XML y JSON

XML a JSON (JavaScript)

fast-xml-parser convierte XML a JSON en Node.js. Los atributos van precedidos (@_ por defecto) y los elementos repetidos se vuelven arrays. La librería es JavaScript puro y rápida, con opciones para controlar arrays, números y booleanos.

xml
// Node.js with fast-xml-parser
const { XMLParser } = require("fast-xml-parser");

const xml = "<book id='b1'><title>XML</title><price>29.99</price></book>";
const parser = new XMLParser({
  ignoreAttributes: false,
  attributeNamePrefix: "@_",
});

const json = parser.parse(xml);
console.log(json.book["@_id"]);   // b1
console.log(json.book.title);     // XML
console.log(json.book.price);     // 29.99

JSON a XML (JavaScript)

XMLBuilder invierte la conversión. El prefijo @_ marca atributos y los objetos anidados se vuelven elementos hijos. Los arrays producen elementos repetidos. La regla de raíz única de XML significa que el objeto JSON de nivel superior debe mapear a un elemento raíz.

xml
const { XMLBuilder } = require("fast-xml-parser");

const json = {
  book: {
    "@_id": "b1",
    title: "XML Guide",
    price: 29.99,
  },
};

const builder = new XMLBuilder({
  format: true,
  attributeNamePrefix: "@_",
  ignoreAttributes: false,
});

const xml = builder.build(json);
console.log(xml);
// <book id="b1">
//   <title>XML Guide</title>
//   <price>29.99</price>
// </book>

xmltodict de Python

xmltodict trata el XML como estructuras dict/list: los atributos usan '@nombre' y el texto '#text'. parse() lee XML, unparse() lo escribe. Es genial para viajes de ida y vuelta rápidos pero pierde el orden y algunos casos límite en esquemas complejos.

xml
import xmltodict, json

xml = """<book id="b1"><title>XML</title><price>29.99</price></book>"""

# XML -> dict
data = xmltodict.parse(xml)
print(data["book"]["@id"])      # b1
print(data["book"]["title"])    # XML

# dict -> JSON
print(json.dumps(data, indent=2))

# dict -> XML
xml_out = xmltodict.unparse({"book": {"@id": "b2", "title": "New"}})
print(xml_out)

Manejo de atributos y texto

Convertir XML a JSON fuerza decisiones sobre los atributos (@_prefijo), el texto (#text) y el contenido mixto. El contenido mixto—texto intercalado con elementos hijos—no se mapea limpiamente a JSON y a menudo pierde fidelidad. Elige convenciones y sé consistente.

xml
<!-- XML with mixed attributes and text -->
<product sku="A1" stock="5">Widget<note>sale</note></product>

// fast-xml-parser output:
// {
//   product: {
//     "@_sku": "A1",
//     "@_stock": "5",
//     "#text": "Widget",
//     note: "sale"
//   }
// }

// Round-trip carefully: mixed content (text + elements)
// is hard to represent losslessly in JSON -->

Desafíos de conversión

Trampas comunes de conversión: hijo único frente a múltiples (array frente a cadena), orden de elementos, prefijos de espacios de nombres (que son alias), la restricción de raíz única y el tipado primitivo (XML no tiene números ni booleanos nativos). Documenta tus convenciones.

xml
<!-- 1. Repeated elements -> array -->
<list><item>a</item><item>b</item></list>
// { list: { item: ["a", "b"] } }   (or single string if only one)

<!-- 2. Order is significant in XML but not in JSON objects -->
<a><x/><y/></a>   vs   <a><y/><x/></a>   // may differ

<!-- 3. Namespaces -->
<ns:elem xmlns:ns="http://x"/>   // prefixes are aliases

<!-- 4. Single root: JSON top-level must be one object -->
<!-- 5. Numbers/booleans: XML is all text; typing is heuristic -->

Ejemplo de ida y vuelta

El viaje de ida y vuelta (XML -> JSON -> XML) funciona para datos bien estructurados pero puede descartar comentarios, instrucciones de procesamiento, límites de CDATA y el espacio en blanco exacto. Para una edición sin pérdidas, usa una API de DOM/árbol en lugar de la conversión a JSON.

xml
// Parse, modify, and re-serialize with fast-xml-parser
const { XMLParser, XMLBuilder } = require("fast-xml-parser");

const opts = { ignoreAttributes: false, attributeNamePrefix: "@_" };
const parser = new XMLParser(opts);
const builder = new XMLBuilder({ ...opts, format: true });

const obj = parser.parse(xmlString);
// mutate
obj.book.price = 19.99;
obj.book["@_onSale"] = "true";

const newXml = builder.build(obj);
console.log(newXml);
14

Feeds RSS y Atom

Estructura RSS 2.0

RSS 2.0 tiene una raíz <rss> con un <channel>. Campos obligatorios del channel: title, link, description. Cada <item> lleva title, link, description, guid, pubDate. Las fechas siguen RFC 822 (por ejemplo, 'Wed, 02 Oct 2024 13:00:00 GMT').

xml
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>My Blog</title>
    <link>https://example.com</link>
    <description>Recent posts</description>
    <language>en-us</language>
    <pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>
    <item>
      <title>First Post</title>
      <link>https://example.com/1</link>
      <description>A short summary</description>
      <pubDate>Wed, 02 Oct 2024 12:00:00 GMT</pubDate>
      <guid>https://example.com/1</guid>
    </item>
  </channel>
</rss>

Channel e item de RSS

Los campos a nivel de channel describen el feed (title, link, description, language, ttl, image). Los campos de item describen cada entrada; enclosure soporta podcasts/medios con una URL, longitud en bytes y tipo MIME. category puede llevar un atributo domain.

xml
<channel>
  <title>Site Title</title>
  <link>https://example.com</link>
  <description>What the feed is about</description>
  <category>Technology</category>
  <ttl>60</ttl>                          <!-- cache minutes -->
  <image>
    <url>https://example.com/logo.png</url>
    <title>Site Title</title>
    <link>https://example.com</link>
  </image>
  <item>
    <title>Post Title</title>
    <link>https://example.com/post</link>
    <description>Summary text</description>
    <author>[email protected]</author>
    <category domain="https://example.com/tags">xml</category>
    <enclosure url="https://example.com/p.mp3" length="12345"
               type="audio/mpeg"/>
  </item>
</channel>

Feed Atom

Atom (RFC 4287) usa una raíz <feed> en el espacio de nombres Atom. Obligatorios: id, title, updated. Las entries necesitan id, title, updated. Los IDs deberían ser globalmente únicos (URNs o URIs tag:). Las fechas usan RFC 3339 (ISO 8601) con zona horaria.

xml
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Example Feed</title>
  <link href="https://example.com/feed.atom" rel="self"/>
  <link href="https://example.com"/>
  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
  <updated>2024-10-02T13:00:00Z</updated>
  <author><name>Jane Doe</name></author>
  <entry>
    <title>Atom Entry</title>
    <id>tag:example.com,2024:/post/1</id>
    <updated>2024-10-02T12:00:00Z</updated>
    <summary>A short summary</summary>
    <content type="html">&lt;p&gt;Full post body&lt;/p&gt;</content>
  </entry>
</feed>

Detalles de la entry de Atom

Las entries de Atom soportan contenido rico: texto, html o xhtml vía el atributo type. link usa atributos rel (alternate, self, enclosure, related). category lleva term/scheme/label. published es la fecha original; updated el último cambio.

xml
<entry>
  <title type="text">Post Title</title>
  <id>tag:example.com,2024:/posts/42</id>
  <updated>2024-10-02T12:00:00Z</updated>
  <published>2024-10-01T09:00:00Z</published>
  <author>
    <name>Jane Doe</name>
    <email>[email protected]</email>
    <uri>https://example.com/jane</uri>
  </author>
  <link href="https://example.com/posts/42" rel="alternate"/>
  <category term="xml" scheme="https://example.com/tags" label="XML"/>
  <summary type="text">A teaser.</summary>
  <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml"><p>Body</p></div>
  </content>
</entry>

Espacios de nombres comunes de feeds

RSS suele extenderse con módulos: Dublin Core (dc:creator, dc:date), content (content:encoded para HTML completo), Media RSS (media:content) y el atom:link rel='self' que ayuda a los lectores a hallar la URL del feed. Los espacios de nombres dejan que los feeds mezclen vocabularios.

xml
<?xml version="1.0"?>
<rss version="2.0"
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:media="http://search.yahoo.com/mrss/"
     xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Feed</title>
    <link>https://example.com</link>
    <description>desc</description>
    <atom:link href="https://example.com/feed.xml" rel="self"
               type="application/rss+xml"/>
    <item>
      <title>Post</title>
      <dc:creator>Jane Doe</dc:creator>
      <content:encoded><![CDATA[<p>HTML body</p>]]></content:encoded>
      <media:content url="https://example.com/img.png" medium="image"/>
    </item>
  </channel>
</rss>

Validación de feeds

Usa el W3C Feed Validator para comprobar RSS/Atom. Errores comunes: campos obligatorios faltantes, formatos de fecha malos, IDs no únicos, XML inválido (& sin escapar) y falta el enlace self. Los feeds válidos garantizan que los agregadores los parseen de forma fiable.

xml
<!-- RSS: dates must be RFC 822, e.g. -->
<pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>

<!-- Atom: dates must be RFC 3339, e.g. -->
<updated>2024-10-02T13:00:00Z</updated>

<!-- Validate online with https://validator.w3.org/feed/ -->
<!-- Required RSS channel fields: title, link, description -->
<!-- Required Atom feed fields: id, title, updated -->
<!-- GUIDs/IDs should be unique and permanent -->
15

SVG y XML

Estructura del documento SVG

SVG es un vocabulario XML para gráficos vectoriales. La raíz <svg> declara el espacio de nombres SVG y un viewBox para el sistema de coordenadas. Cada elemento gráfico (rect, circle, text) es un elemento XML con atributos de presentación.

xml
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     width="200" height="200" viewBox="0 0 200 200">
  <rect x="10" y="10" width="180" height="180"
        fill="#005FAD" stroke="black" stroke-width="2"/>
  <circle cx="100" cy="100" r="40" fill="white"/>
  <text x="100" y="105" text-anchor="middle">SVG</text>
</svg>
<!-- SVG is an XML application; it must be well-formed -->

Espacio de nombres e imports SVG

Los elementos SVG viven en el espacio de nombres http://www.w3.org/2000/svg. xlink se usa para las referencias href (en SVG 1.1); SVG 2 prefiere el href plano. defs guarda degradados, patrones y símbolos reutilizables referenciados por id vía url(#id).

xml
<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     version="1.1">
  <defs>
    <linearGradient id="g1">
      <stop offset="0%" stop-color="red"/>
      <stop offset="100%" stop-color="blue"/>
    </linearGradient>
  </defs>
  <rect width="100" height="100" fill="url(#g1)"/>
</svg>

Formas SVG

Elementos de forma SVG: rect (con rx/ry para esquinas redondeadas), circle, ellipse, line, polyline (abierta) y polygon (cerrada). Las coordenadas están en las unidades de usuario definidas por el viewBox. stroke y fill son atributos de presentación comunes.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200">
  <rect x="10" y="10" width="80" height="50" rx="10" fill="teal"/>
  <circle cx="150" cy="60" r="40" fill="orange"/>
  <ellipse cx="220" cy="60" rx="50" ry="20" fill="purple"/>
  <line x1="10" y1="120" x2="290" y2="120" stroke="black"/>
  <polyline points="10,180 50,140 90,180 130,140" fill="none" stroke="red"/>
  <polygon points="200,180 250,140 280,200" fill="green"/>
</svg>

Texto y paths SVG

El texto SVG usa font-family, font-size, font-weight, font-style. tspan permite estilos mixtos dentro de un elemento text. El atributo 'd' del elemento path usa comandos: M (mover), L (línea), C (bezier cúbica), Q (cuadrática), A (arco), Z (cerrar path).

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="150">
  <text x="10" y="40" font-family="Arial" font-size="24"
        font-weight="bold" fill="navy">Hello SVG</text>

  <text x="10" y="80">
    <tspan font-size="16">Normal</tspan>
    <tspan font-size="16" font-style="italic"> italic</tspan>
  </text>

  <path d="M10 100 L 100 100 L 55 140 Z"
        fill="none" stroke="black" stroke-width="2"/>
</svg>
<!-- Path commands: M=move, L=line, H/V, C=cubic, Q=quad, A=arc, Z=close -->

Agrupación y reutilización SVG

El elemento <g> agrupa formas para estilos y transformaciones compartidos. <use> referencia un elemento por id (href='#id' en SVG 2, xlink:href en 1.1) y lo clona en una posición nueva. <symbol> define gráficos reutilizables que solo se renderizan vía <use>.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
  <g id="node" stroke="black" fill="lightblue">
    <circle cx="50" cy="50" r="20"/>
    <circle cx="100" cy="50" r="20"/>
  </g>

  <use href="#node" x="0" y="100"/>
  <use href="#node" x="0" y="150" opacity="0.5"/>

  <symbol id="star" viewBox="0 0 24 24">
    <polygon points="12,2 15,9 22,9 17,14 19,21 12,17 5,21 7,14 2,9 9,9"/>
  </symbol>
  <use href="#star" width="24" height="24"/>
</svg>

Validación SVG

Los documentos SVG pueden validarse contra el DTD o XSD del W3C. Problemas comunes: olvidar el espacio de nombres SVG, prefijos no declarados, atributos en el espacio de nombres equivocado y datos de path malformados. xmllint es el validador estándar de línea de comandos.

xml
<?xml version="1.0"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <rect width="100" height="100"/>
</svg>

<!-- Validate with xmllint: -->
<!-- xmllint --noout --valid file.svg        (DTD) -->
<!-- xmllint --noout --schema svg11.xsd file.svg   (XSD) -->

<!-- Common errors: wrong namespace, undeclared prefixes,
     text outside a text element, invalid path data -->
16

SOAP y WSDL

Envelope SOAP

Un mensaje SOAP es un documento XML con una raíz <Envelope> en el espacio de nombres SOAP. El <Header> opcional lleva metadatos (auth, enrutado); el <Body> obligatorio guarda el payload real del mensaje. SOAP 1.1 y 1.2 usan espacios de nombres distintos.

xml
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <auth xmlns="https://example.com/auth">
      <token>abc123</token>
    </auth>
  </soap:Header>
  <soap:Body>
    <m:GetPrice xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>
<!-- Envelope is the root; Header is optional, Body is required -->

Header SOAP

Los headers llevan información fuera de banda como autenticación, direccionamiento (WS-Addressing) y transacciones. soap:mustUnderstand='1' indica al receptor que DEBE procesar este header o devolver un fault SOAP—esto impone el cumplimiento del contrato.

xml
<soap:Header xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">
    http://example.com/GetPrice
  </wsa:Action>
  <wsa:MessageID>urn:uuid:1234</wsa:MessageID>
  <auth xmlns="https://example.com/auth"
        soap:mustUnderstand="1">
    <token>secret</token>
  </auth>
</soap:Header>
<!-- mustUnderstand="1" forces the receiver to process the header -->

Body y Fault SOAP

El Body lleva el payload de la petición o respuesta. Ante error, el Body contiene un <Fault> con faultcode (Client/Server), un faultstring legible por humanos y un detail opcional. SOAP 1.2 renombra estos elementos y añade una estructura Code/Reason.

xml
<!-- Request body -->
<soap:Body>
  <m:GetPrice xmlns:m="https://example.com/pricing">
    <m:Item>Apples</m:Item>
  </m:GetPrice>
</soap:Body>

<!-- Fault (error response) -->
<soap:Body>
  <soap:Fault>
    <faultcode>soap:Client</faultcode>
    <faultstring>Unknown item: Apples</faultstring>
    <detail>
      <m:Error xmlns:m="https://example.com/pricing">
        <code>404</code>
      </m:Error>
    </detail>
  </soap:Fault>
</soap:Body>

Estructura WSDL

WSDL describe un servicio web: <types> (esquemas XSD), <message> (payloads de entrada/salida), <portType> (la interfaz—operaciones y sus mensajes), <binding> (protocolo/codificación) y <service> (URL del endpoint). WSDL 2.0 lo simplifica a interfaces y bindings.

xml
<?xml version="1.0"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
             xmlns:xs="http://www.w3.org/2001/XMLSchema"
             targetNamespace="https://example.com/pricing">
  <types>
    <xs:schema targetNamespace="https://example.com/pricing">
      <xs:element name="GetPriceRequest" type="xs:string"/>
      <xs:element name="GetPriceResponse" type="xs:decimal"/>
    </xs:schema>
  </types>
  <message name="GetPriceInput">
    <part name="item" element="tns:GetPriceRequest"/>
  </message>
  <portType name="PricingPort">
    <operation name="GetPrice">
      <input message="tns:GetPriceInput"/>
      <output message="tns:GetPriceOutput"/>
    </operation>
  </portType>
</definitions>

Binding y service de WSDL

El binding mapea un portType a un protocolo concreto (SOAP sobre HTTP) y un estilo (document/literal es el moderno por defecto). El elemento service lista los endpoints (soap:address). Document/literal envuelve el payload en un elemento definido por esquema.

xml
<binding name="PricingSOAP" type="tns:PricingPort">
  <soap:binding style="document"
                transport="http://schemas.xmlsoap.org/soap/http"/>
  <operation name="GetPrice">
    <soap:operation soapAction="http://example.com/GetPrice"/>
    <input><soap:body use="literal"/></input>
    <output><soap:body use="literal"/></output>
  </operation>
</binding>

<service name="PricingService">
  <port name="PricingPort" binding="tns:PricingSOAP">
    <soap:address location="https://example.com/pricing"/>
  </port>
</service>
<!-- style: rpc or document; use: encoded or literal -->

SOAP vs REST

SOAP es un protocolo con un envelope XML estricto, contrato WSDL y estándares WS-* (seguridad, transacciones); lo mejor para integraciones empresariales que exigen fiabilidad y contratos formales. REST es un estilo ligero basado en HTTP, normalmente con JSON, que domina las APIs públicas.

xml
<!-- SOAP: protocol with envelope, strict contract (WSDL),
     built-in error model (Fault), WS-* extensions.
     Heavier, XML-only, common in enterprise/B2B. -->

<!-- REST: architectural style using HTTP verbs (GET/POST/...),
     flexible payloads (often JSON), no built-in contract.
     Lighter, browser-friendly, dominant on the web. -->

<!-- When to use SOAP:
     - you need strict contracts and tooling
     - transactional reliability (WS-ReliableMessaging)
     - standardized security (WS-Security)
     - existing SOAP-based infrastructure -->

<!-- When to use REST:
     - public APIs, mobile/web clients
     - JSON payloads, HTTP caching
     - simpler, faster iteration -->
17

Firma digital XML

Estructura de la firma

La raíz <Signature> de una firma XML contiene <SignedInfo> (qué se firma y cómo), <SignatureValue> (la firma criptográfica sobre el SignedInfo canonizado), un <KeyInfo> opcional y <Object>s que guardan los datos referenciados.

xml
<?xml version="1.0"?>
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
  <SignedInfo>
    <CanonicalizationMethod Algorithm="..."/>
    <SignatureMethod Algorithm="..."/>
    <Reference URI="#data">
      <DigestMethod Algorithm="..."/>
      <DigestValue>...</DigestValue>
    </Reference>
  </SignedInfo>
  <SignatureValue>...</SignatureValue>
  <KeyInfo>...</KeyInfo>
  <Object Id="data">signed content</Object>
</Signature>
<!-- A signature = SignedInfo + SignatureValue + optional KeyInfo -->

SignedInfo

SignedInfo especifica la canonización (para que una firma idéntica byte a byte sobreviva a la re-serialización del XML), el algoritmo de firma y una o más References. Cada Reference apunta a datos vía URI, lista Transforms y da un DigestValue de esos datos.

xml
<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
  <CanonicalizationMethod
      Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
  <SignatureMethod
      Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
  <Reference URI="">
    <Transforms>
      <Transform Algorithm="...enveloped-signature"/>
    </Transforms>
    <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    <DigestValue>base64digest==</DigestValue>
  </Reference>
</SignedInfo>

Reference y Transforms

Cada Reference identifica qué firmar (URI), aplica Transforms (canonización, filtrado XPath, eliminación de firma envuelta) y luego hashea con DigestMethod. La transformación enveloped-signature excluye el propio elemento Signature de su propio hash.

xml
<Reference URI="#order">
  <Transforms>
    <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
    <XPath xmlns="...">not(ancestor-or-self::ds:Signature)</XPath>
  </Transforms>
  <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
  <DigestValue>abc123base64==</DigestValue>
</Reference>

<!-- Reference types:
     - same-document (URI="#id")
     - external (URI="https://...")
     - detached (URI pointing elsewhere) -->

SignatureValue y KeyInfo

SignatureValue es el resultado base64 de firmar el SignedInfo canonizado con la clave privada del firmante. KeyInfo es OPCIONAL y solo insinúa cómo hallar la clave de verificación (certificado X.509, clave pública RSA, nombre de clave o URL de recuperación)—debe validarse fuera de banda.

xml
<SignatureValue>base64encodedSignature==</SignatureValue>

<KeyInfo>
  <X509Data>
    <X509SubjectName>CN=Example,O=Example Inc</X509SubjectName>
    <X509Certificate>MIID...base64...==</X509Certificate>
  </X509Data>
</KeyInfo>

<!-- Other KeyInfo options: -->
<!--   <KeyName>key-id</KeyName> -->
<!--   <KeyValue><RSAKeyValue>...</RSAKeyValue></KeyValue> -->
<!--   <RetrievalMethod URI="..."/> -->
<!-- KeyInfo is optional and unverified by itself -->

Canonización

La canonización convierte un conjunto de nodos XML en bytes estables para que una firma sea reproducible pese a diferencias irrelevantes (orden de atributos, CDATA). Exclusive c14n (xml-exc-c14n) es la preferida para firmas porque acota los espacios de nombres al subárbol firmado.

xml
<!-- Two documents that are logically identical may differ in bytes:
     - attribute order
     - namespace declarations
     - CDATA vs escaping
     - whitespace outside elements
     Canonical XML (c14n) produces a canonical byte form. -->

<CanonicalizationMethod
    Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

<!-- Exclusive c14n (recommended for signatures): -->
<CanonicalizationMethod
    Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>

<!-- Exclusive form avoids leaking inherited namespace declarations
     into the signed digest, preventing wrapping attacks. -->

Firma envuelta (enveloped)

Una firma enveloped se incrusta dentro del documento que firma (lo más común para XML). La transformación enveloped-signature elimina el elemento <Signature> antes de hashear, así que la firma no forma parte de su propio digest. También existen las variantes detached y enveloping.

xml
<?xml version="1.0"?>
<order Id="order">
  <item>Widget</item>
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod Algorithm="...exc-c14n#"/>
      <SignatureMethod Algorithm="...rsa-sha256"/>
      <Reference URI="#order">
        <Transforms>
          <Transform Algorithm="...enveloped-signature"/>
        </Transforms>
        <DigestMethod Algorithm="...sha256"/>
        <DigestValue>...</DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue>...</SignatureValue>
  </Signature>
</order>
<!-- The signature lives INSIDE the signed element -->
19

Convenciones de nombrado

Nombrado de elementos

Elige un estilo y aplícalo consistentemente. Minúsculas-con-guiones es lo común para los vocabularios XML (HTML, SVG). Los nombres deberían ser descriptivos lo suficiente para no ser ambiguos pero concisos. Evita las abreviaturas crípticas y los nombres demasiado verbosos.

xml
<!-- Good: lowercase, hyphen-separated, descriptive -->
<customer-address>
  <street>123 Main St</street>
  <postal-code>12345</postal-code>
</customer-address>

<!-- Avoid: abbreviations that are unclear -->
<!-- <cust-addr><pc>...</pc></cust-addr> -->

<!-- Avoid: too long -->
<!-- <customerMailingPostalAddressCode> -->

<!-- Be consistent across the whole vocabulary -->

Nombrado de atributos

Los atributos encajan con los metadatos (id, type, href, status). Iguala el estilo de nombrado del elemento. Los booleanos llevan valores explícitos. No antepongas al atributo el nombre de su elemento (user-id sobre <user> es redundante). Usa 'id' para los identificadores únicos.

xml
<product sku="A1" unit-price="9.99" in-stock="true">
  <name>Widget</name>
</product>

<!-- Conventions:
     - attributes are metadata: id, type, href, status
     - use lowercase-hyphen style to match elements
     - boolean attributes still carry a value ("true"/"false")
     - avoid repeating the element name: <user user-id="..."/>
       prefer <user id="..."/> -->

<!-- IDs: use 'id' or '<element>-id' for clarity -->

URIs y prefijos de espacios de nombres

Los URIs de espacios de nombres son identificadores, no URLs obtenibles, pero deberían ser estables y de tu propiedad (usa HTTPS en un dominio que controles). Los prefijos son alias locales—mantenlos cortos y convencionales. Versiona el URI cuando el esquema cambie de forma incompatible.

xml
<!-- Namespace URIs should be stable, owned, and permanent -->
xmlns:bk  = "https://example.com/ns/books/2024"
xmlns:auth= "https://example.com/ns/auth"

<!-- Prefix conventions:
     - short and mnemonic: xs, xsi, xsl, svg, html, dc
     - lowercase, no punctuation beyond letters
     - 'tns' commonly means 'this namespace' in XSD
     - avoid 'xml' (reserved) -->

<!-- Version the URI when the vocabulary changes incompatibly:
     .../ns/books/2024  vs  .../ns/books/2025 -->

Estilos de mayúsculas

Estilos de mayúsculas comunes en XML: PascalCase (XSD/WSDL, .NET), camelCase (derivado de JSON, Java), minúsculas-con-guiones (HTML/SVG, amigable con REST), snake_case (raro). La regla crucial es la consistencia dentro de un vocabulario—mezclar estilos es confuso.

xml
<!-- PascalCase (UpperCamelCase): common in XSD/WSDL, .NET -->
<OrderRequest>
  <CustomerId>123</CustomerId>
</OrderRequest>

<!-- camelCase: common in JSON-derived XML, Java ecosystems -->
<orderRequest>
  <customerId>123</customerId>
</orderRequest>

<!-- lowercase-with-hyphens: HTML5, SVG, REST-friendly -->
<order-request>
  <customer-id>123</customer-id>
</order-request>

<!-- snake_case: rare in XML, used in some Python/SQL ecosystems -->
<order_request><customer_id>123</customer_id></order_request>

Versionado

Versiona explícitamente los vocabularios XML: un atributo version en la raíz es lo más simple; un URI de espacio de namespaces versionado es lo más riguroso (los cambios incompatibles reciben un URI nuevo). Decide qué cuenta como cambio menor (aditivo) frente a mayor (que rompe) y documéntalo.

xml
<!-- Versioning strategies -->

<!-- 1. Attribute on the root -->
<catalog version="2.0">...</catalog>

<!-- 2. Versioned namespace URI -->
<catalog xmlns="https://example.com/ns/catalog/v2">...</catalog>

<!-- 3. Versioned root element name -->
<catalog-v2>...</catalog-v2>

<!-- Backward-compatible changes: add optional elements/attributes
     Incompatible changes: bump the version (and/or namespace) -->

<!-- Document the policy: which changes are "minor" vs "major" -->

Convenciones de archivos y extensiones

Usa extensiones reconocidas para que las herramientas y los humanos identifiquen los tipos de archivo. El atributo encoding de la declaración XML debería coincidir con la codificación real de bytes; UTF-8 es el valor por defecto seguro. Los BOMs están desaconsejados para XML UTF-8.

xml
<!-- Common file extensions:
     .xml   generic XML
     .xsd   XML Schema
     .xsl   XSLT stylesheet
     .xslt  XSLT (alternate)
     .dtd   Document Type Definition
     .rss   RSS feed
     .atom  Atom feed
     .svg   SVG graphic
     .wsdl  WSDL service description
     .xhtml XHTML document
     .plist Apple property list -->

<!-- XML files are UTF-8 by default; declare encoding if different:
     <?xml version="1.0" encoding="UTF-8"?> -->
20

Buenas prácticas

Primero bien formado

Un documento debe estar bien formado antes de que cualquier herramienta lo procese. Valida con un parser temprano: xmllint --noout archivo.xml reporta el primer error. El buen formado es innegociable; la validez contra un esquema es una capa adicional y opcional.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <child>properly nested &amp; escaped</child>
</root>

<!-- Always ensure well-formedness before worrying about validity:
     - exactly one root element
     - all tags closed and properly nested
     - attributes quoted and unique per element
     - & < escaped (and > in some contexts)
     - valid encoding declaration -->

Validación y esquemas

Valida contra un esquema para atrapar errores estructurales. XSD es la elección más común para vocabularios tipados y con espacios de nombres; Schematron lo complementa con reglas de negocio. xsi:noNamespaceSchemaLocation enlaza un documento a su XSD; usa xsi:schemaLocation para esquemas con espacios de nombres.

xml
<!-- Choose a schema language:
     - DTD:      simple, built-in, limited types
     - XSD:      rich types, namespaces, industry standard
     - RelaxNG:  compact syntax, flexible patterns
     - Schematron: rule-based business constraints -->

<?xml version="1.0"?>
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="schema.xsd">
  <item>valid</item>
</root>

<!-- Validate during development; consider it at runtime for
     untrusted input. -->

Codificación (UTF-8)

UTF-8 es la codificación por defecto y recomendada para XML—maneja Unicode por completo sin entidades. Declara siempre la codificación y guarda el archivo en esa codificación. Evita los BOMs; para caracteres especiales también puedes usar referencias numéricas de caracteres.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <msg>Café — résumé — 中文 — emoji 🙂</msg>
</root>

<!-- Always declare UTF-8 and save the file as UTF-8.
     Avoid legacy encodings (ISO-8859-1) unless required.
     Do not add a UTF-8 BOM (some parsers mishandle it).
     For non-UTF-8 encodings, declare them accurately. -->

Legibilidad y sangría

Una sangría consistente (2 espacios es lo común) hace el XML legible y los diffs limpios. Evita las líneas únicas largas. Herramientas como 'xmllint --format' o un formateador XML pueden normalizar el espacio en blanco—pero ten en cuenta que las regiones con xml:space='preserve' no deben reformatearse.

xml
<?xml version="1.0"?>
<catalog>
  <book id="b1">
    <title>XML Guide</title>
    <author>Jane Doe</author>
  </book>
  <book id="b2">
    <title>Advanced XML</title>
    <author>John Smith</author>
  </book>
</catalog>

<!-- Use 2-space indentation; one element per line for mixed
     or deep structures. Tools: xmllint --format, prettier. -->

Rendimiento

Para archivos grandes, prefiere los parsers en streaming (SAX/StAX) sobre el DOM para mantener la memoria baja. Deshabilita la carga de DTDs y entidades externas salvo que las necesites. Compila las expresiones XPath una vez y reutilízalas. Para sistemas internos, considera formatos binarios compactos para recortar tamaño y tiempo de parseo.

xml
<!-- Parsing large XML efficiently:
     - use SAX/StAX (streaming) instead of DOM for big files
     - disable DTD/external entities if you don't need them
     - validate once, not on every read
     - reuse parser instances (factory creation is costly)
     - consider binary formats (protobuf, CBOR) for internal traffic -->

<!-- Java StAX with XXE disabled:
     factory.setProperty(XMLInputFactory.SUPPORT_DTD, false); -->

<!-- For repeated XPath, compile once and reuse the expression -->

Seguridad (XXE)

Los ataques XXE (XML External Entity) abusan de las entidades externas del DTD para leer archivos, disparar SSRF o causar denegación de servicio (billion laughs/expansión de entidades). La defensa más fuerte es deshabilitar por completo los DTDs y la resolución de entidades externas salvo que tu caso de uso las exija.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!-- XXE: attacker forces the parser to read a local file -->
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>&xxe;</root>

<!-- Defenses (do ALL that apply):
     1. Disable DTDs entirely if you don't need them.
     2. Disable external entity resolution.
     3. Disable XInclude.
     4. Validate input; limit entity expansion (billion laughs). -->

<!-- Python: defusedxml
     Java:  XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES = false
     PHP:   libxml_disable_entity_loader(true) -->

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.