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 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 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 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.
<!-- 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 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 version="1.0"?>
<root>
<code><![CDATA[
if (a < b && c > d) {
console.log("no escaping needed: < > & ");
}
]]></code>
</root>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.
<!-- 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.
<!-- 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.
<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 ". Un atributo puede aparecer solo una vez por elemento—usa elementos hijos para valores repetidos.
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said "hi""/>
<msg text='She said 'hi''/>
<!-- 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.
<!-- 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.
<!-- 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) -->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 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 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 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 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.
<!-- 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 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>CDATA y entidades
Entidades predefinidas
XML predefine cinco entidades: < (<), > (>), & (&), ' ('), " ("). & debe escaparse SIEMPRE (incluso en texto sin CDATA); < debe escaparse salvo como inicio de etiqueta; las comillas importan principalmente en los atributos.
<?xml version="1.0"?>
<root>
<lt>less than: <</lt>
<gt>greater than: ></gt>
<amp>ampersand: &</amp>
<apos>apostrophe: '</apos>
<quot>quote: "</quot>
<!-- < > & ' " are the 5 built-in entities -->
</root>Referencias de caracteres
Las referencias de caracteres usan un punto de código Unicode: © (decimal) o © (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 version="1.0" encoding="UTF-8"?>
<root>
<decimal>© 2024 Company</decimal>
<hex>© 2024 Company</hex>
<euro>Price: €10</euro>
<emoji>Smile: 😀</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 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 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>©right;</footer>
</root>
<!-- Entities are expanded during parsing -->Escapar en atributos
Dentro de los valores de atributo debes escapar & como &, y escapar el carácter de comilla usado para delimitar el valor (" o '). < también debería escaparse. Los saltos de línea y tabulaciones en los atributos se normalizan a espacios por el parser.
<?xml version="1.0"?>
<root>
<link url="https://example.com?a=1&b=2"/>
<msg text="Say "hello" & smile"/>
<path value='C:\Users\name'/>
<data value="<tagged>"/>
</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 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>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 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.
<!-- 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).
<!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.
<!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.
<!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 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)) -->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 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.
<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.
<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.
<!-- 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).
<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.
<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>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.
<!-- 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.
//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.
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.
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.
<!-- 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 | //magazineEjemplos 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.
<!-- 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']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 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.
<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.
<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.
<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 < dentro de los valores de atributo en el XML de la hoja de estilo.
<xsl:variable name="max-price" select="50"/>
<xsl:for-each select="bookstore/book[price < $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 < 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.
<!-- 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"/>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.
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.
(: 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')//titlePredicados 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.
(: 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.
(: 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.
(: 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.
(: 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 -->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.
// 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 insteadRecorrido 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).
// 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.
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.
// 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.
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.
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"))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.
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.
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.
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.
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.
<!-- 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.
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")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.
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().
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.
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.
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.
<!-- 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.
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();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.
// 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.99JSON 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.
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.
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 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.
<!-- 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.
// 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);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 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.
<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 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"><p>Full post body</p></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.
<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 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.
<!-- 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 -->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 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 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.
<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).
<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>.
<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 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 -->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 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.
<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.
<!-- 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 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.
<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.
<!-- 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 -->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 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.
<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.
<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.
<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.
<!-- 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 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 -->XLink y XPointer
Enlace simple XLink
Los enlaces simples XLink imitan a las anclas HTML en XML arbitrario. xlink:type='simple' hace un enlace unidireccional básico; xlink:href es el objetivo. show controla la visualización (new/replace/embed); actuate controla el momento (onRequest/onLoad).
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<web xlink:type="simple"
xlink:href="https://example.com"
xlink:role="https://example.com/roles/home"
xlink:title="Example Site"
xlink:show="new"
xlink:actuate="onRequest">
Visit Example
</web>
</root>
<!-- A simple link is a one-way hyperlink, similar to HTML <a> -->Enlace extendido XLink
Los enlaces extendidos conectan varios recursos (localizadores) vía arcs. Cada localizador lleva una label; los arcs definen el recorrido entre labels (from/to). Los enlaces fuera de línea pueden vivir en un documento aparte, habilitando el enlace multidireccional entre recursos de terceros.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<link xlink:type="extended" xlink:role="https://example.com/mapping">
<loc xlink:type="locator" xlink:label="src"
xlink:href="https://a.example/doc1" xlink:title="Doc A"/>
<loc xlink:type="locator" xlink:label="dst"
xlink:href="https://b.example/doc2" xlink:title="Doc B"/>
<go xlink:type="arc" xlink:from="src" xlink:to="dst"
xlink:show="new" xlink:actuate="onRequest"/>
</link>
</root>
<!-- Extended links can connect multiple resources and be out-of-line -->Atributos XLink
Los atributos XLink se reparten por tipo. href apunta a un localizador/recurso; label nombra a un participante para los arcs; from/to conectan los arcs; role/arcrole son URIs semánticos (a menudo términos de Dublin Core o RELAX NG). show/actuate dirigen la presentación y el comportamiento de carga.
<!-- xlink:type: simple | extended | locator | arc | resource | title | none -->
<!-- Common attributes by type -->
<el xlink:type="simple" xlink:href="..." xlink:role="..." xlink:title="..."
xlink:show="new|replace|embed|other|none"
xlink:actuate="onRequest|onLoad|other|none"/>
<el xlink:type="locator" xlink:href="..." xlink:label="..." xlink:role="..."/>
<el xlink:type="arc" xlink:from="..." xlink:to="..." xlink:show="..."/>
<el xlink:type="resource" xlink:label="..." xlink:role="..."/>
<!-- xlink:role is a URI identifying the resource's meaning -->
<!-- xlink:arcrole describes the arc (relationship) itself -->Fundamentos de XPointer
XPointer direcciona posiciones dentro de un documento XML vía fragmentos de URI. La forma abreviada (#id) selecciona por ID. Las formas basadas en esquema (#xpointer(...)) usan XPath, y element() usa rutas posicionales de hijos. El fragmento se interpreta tras obtener el documento.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- XPointer extends a URI fragment to address XML parts -->
<link xlink:type="simple"
xlink:href="doc.xml#xpointer(//book[@id='b1'])"/>
<link xlink:href="doc.xml#xpointer(/root/section[2]/p[1])"/>
<link xlink:href="doc.xml#b1"/>
</root>
<!-- Fragment forms:
- shorthand: #id
- scheme-based: #xpointer(expr)
- element(): #element(/1/2/3) -->Framework XPointer
El framework XPointer deja que varios esquemas se encadenen, de modo que si uno falla se prueba el siguiente. El esquema xmlns() vincula prefijos para usarlos en las expresiones xpointer() siguientes. element() aporta una ruta posicional robusta independiente de los IDs.
<!-- The XPointer Framework defines how fragment schemes compose -->
<ref xlink:href="doc.xml#element(/1/2)"/>
<ref xlink:href="doc.xml#xpointer(//section[@id='s1']/p[2])"/>
<ref xlink:href="doc.xml#xmlns(bk=https://example.com/b)xpointer(//bk:book)"/>
<!-- Multiple schemes can be tried in order: -->
<ref xlink:href="doc.xml#element(/1/2)xpointer(//book[@id='b1'])"/>
<!-- If element() fails, the next scheme is attempted -->
<!-- Common schemes: element(), xpointer(), xmlns(), xpath1() -->Esquema element()
El esquema element() direcciona un nodo por una secuencia de posiciones de hijos base 1, opcionalmente partiendo de un elemento con ID. Es más robusto que xpointer() ante cambios de esquema porque no depende de los nombres de los elementos—solo de la estructura.
<!-- element() addresses by child positions from the root -->
<ref xlink:href="doc.xml#element(/1/2/3)"/>
<!-- selects the 1st child of root, its 2nd child, then 3rd child -->
<!-- or relative to an ID -->
<ref xlink:href="doc.xml#element(b1/2)"/>
<!-- the 2nd child of the element with id="b1" -->
<!-- child positions are 1-based and skip text/attribute nodes;
only element children are counted -->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.
<!-- 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.
<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.
<!-- 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.
<!-- 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.
<!-- 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.
<!-- 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"?> -->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 version="1.0" encoding="UTF-8"?>
<root>
<child>properly nested & 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.
<!-- 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 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 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.
<!-- 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 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) -->Fragmentos de XML relacionados
Copy-paste ready code for common tasks.
Namespaces
Declare and use XML namespaces.
XPath
Path expressions for selecting nodes.
DTD and Schema
Document Type Definition for validation.
DOM and SAX Parsing
Two models for reading XML.
Attributes
Name-value pairs on elements.
CDATA Sections
Escape blocks of literal text.
XSLT
Transform XML into other formats.
Well-Formed XML
Rules every parser enforces.
Was this helpful?