Apuntes extensos de XML y XSLT

by Tomas Gonzalez
on diciembre 5, 2025
COMPARTE ESTE ARTÍCULO

Academia San Roque – Módulo de Lenguajes de Marcas

1. Introducción: ¿Por qué XML y XSLT siguen siendo importantes?

Aunque hoy se habla mucho de JSON, APIs REST y formatos ligeros, XML y XSLT siguen siendo tecnologías clave en muchos entornos profesionales:

  • Sistemas de facturación electrónica y documentos oficiales.
  • Integración entre aplicaciones empresariales (ERP, CRM, etc.).
  • Configuración de aplicaciones Java, .NET, servidores, etc.
  • Transformación de datos entre distintos formatos.

Para entender XSLT, es imprescindible dominar primero las bases de XML, porque XSLT trabaja directamente sobre documentos XML y usa XPath para navegar por su estructura.

En estos apuntes veremos, de forma progresiva y detallada:

  1. Qué es XML y su sintaxis básica.
  2. Cómo se estructura un documento XML (elementos, atributos, espacios de nombres…).
  3. Validación: DTD y XML Schema (XSD) a nivel introductorio.
  4. Qué es XPath y por qué es importante para XSLT.
  5. Qué es XSLT, para qué sirve y cómo se organiza una hoja de estilos.
  6. Principales elementos y construcciones de XSLT (plantillas, variables, ciclos, condiciones…).
  7. Ejemplos prácticos de transformación de XML a HTML, a otro XML y a texto.
  8. Buenas prácticas y errores típicos.

2. Fundamentos de XML

2.1. ¿Qué es XML?

XML (eXtensible Markup Language) es un lenguaje de marcado diseñado para almacenar y transportar datos de forma estructurada. Algunas características importantes:

  • Extensible: no tiene etiquetas predefinidas. Somos nosotros quienes definimos las etiquetas que necesitamos.
  • Auto-descriptivo: la estructura del documento describe el contenido.
  • Texto plano: se puede abrir con cualquier editor de texto.
  • Estandarizado: recomendado por el W3C.

La idea clave: XML no define cómo se ve la información (presentación), sino cómo se estructura.

Ejemplo sencillo de XML

<?xml version="1.0" encoding="UTF-8"?>
<curso>
    <nombre>Lenguajes de Marcas</nombre>
    <centro>Academia San Roque</centro>
    <alumnos>
        <alumno>
            <nombre>Laura</nombre>
            <apellidos>Pérez García</apellidos>
            <nota>8.5</nota>
        </alumno>
        <alumno>
            <nombre>Carlos</nombre>
            <apellidos>Ruiz Martín</apellidos>
            <nota>7.0</nota>
        </alumno>
    </alumnos>
</curso>

En este ejemplo:

  • <curso> es el elemento raíz.
  • Dentro hay elementos hijos: <nombre>, <centro>, <alumnos>, etc.
  • Los datos se guardan como contenido de texto de esos elementos.

2.2. Reglas básicas de sintaxis en XML

XML es muy estricto. Un pequeño error de sintaxis hace que el documento sea inválido. Algunas reglas fundamentales:

  1. Un único elemento raíz.
    • Todo el documento debe estar contenido dentro de un único elemento.
  2. Etiquetas bien anidadas.
    • Lo que se abre, se cierra, y en orden correcto.
  3. Distingue mayúsculas y minúsculas.
    • <Alumno> es distinto de <alumno>.
  4. Atributos entre comillas.
    • Los valores de los atributos deben ir entre comillas simples o dobles.
  5. Caracteres especiales escapados.
    • < y &, entre otros, deben escribirse como entidades en el contenido de texto.

Ejemplos de anidamiento correcto e incorrecto

Correcto:

<persona>
    <nombre>María</nombre>
    <edad>25</edad>
</persona>

Incorrecto (etiquetas mal anidadas):

<persona>
    <nombre>María</edad>
    </nombre>
</persona>

2.3. Prolog de XML

Al principio del documento XML suele aparecer una declaración como esta:

<?xml version="1.0" encoding="UTF-8"?>
  • version indica la versión de XML (lo habitual es 1.0).
  • encoding indica la codificación del documento (UTF-8 es lo más común hoy en día).

Esta línea se llama prolog y ayuda a los procesadores XML a interpretar correctamente el contenido.

2.4. Elementos y atributos

En XML podemos representar información tanto con elementos como con atributos.

2.4.1. Elementos

Los elementos se definen mediante una etiqueta de apertura y otra de cierre:

<nombre>Academia San Roque</nombre>

También existen elementos vacíos, que no tienen contenido, y se pueden escribir con una etiqueta abreviada:

<br />
<img src="logo.png" />

(La sintaxis <br> y <img> es más típica de HTML, pero en XML estricto se recomienda siempre la barra: <br />.)

2.4.2. Atributos

Los atributos añaden información adicional a los elementos, en forma de pares nombre–valor:

<alumno id="A001" repetidor="no">
    <nombre>Lucía</nombre>
    <nota>9.2</nota>
</alumno>

En este ejemplo:

  • id y repetidor son atributos del elemento <alumno>.
  • Sus valores van siempre entre comillas.

2.4.3. ¿Cuándo usar elementos y cuándo atributos?

No hay una norma rígida, pero algunas recomendaciones:

  • Usa elementos para información principal o que pueda repetirse.
  • Usa atributos para metadatos, identificadores o propiedades simples.

Ejemplo con datos como elementos:

<alumno>
    <id>A001</id>
    <repetidor>no</repetidor>
    <nombre>Lucía</nombre>
</alumno>

Ambos enfoques son válidos, pero el diseño debe ser coherente en todo el documento.

2.5. Contenido de texto y entidades especiales

En XML, el texto que va entre las etiquetas se llama contenido de texto. Cuando necesitamos escribir ciertos caracteres especiales, debemos usar entidades.

Las más frecuentes:

  • &lt; para <
  • &gt; para >
  • &amp; para &
  • &quot; para "
  • &apos; para '

Ejemplo:

<mensaje>5 &lt; 10 y 10 &gt; 5, y usar &amp; es obligatorio.</mensaje>

2.6. Espacios de nombres (namespaces)

Los espacios de nombres evitan conflictos cuando combinamos XML de diferentes fuentes que usan nombres de etiquetas iguales.

Se declaran con el atributo especial xmlns:

<libro xmlns="http://ejemplo.org/libros">
    <titulo>Introducción a XML</titulo>
</libro>

También podemos usar un prefijo:

<l:libro xmlns:l="http://ejemplo.org/libros">
    <l:titulo>Introducción a XML</l:titulo>
</l:libro>
  • xmlns:l declara que el prefijo l pertenece a un determinado URI.
  • Esto ayuda a que procesadores XML o XSLT distingan entre elementos de distintos vocabularios.

3. Validación de XML: DTD y XML Schema (XSD)

Además de estar bien formado (sin errores de sintaxis), un XML puede estar validado contra una definición de estructura:

  • DTD (Document Type Definition).
  • XML Schema (XSD).

La validación sirve para garantizar que un XML cumple ciertas reglas:

  • Qué elementos pueden aparecer.
  • En qué orden.
  • Qué atributos son obligatorios.
  • Tipos de datos (números, fechas, etc.).

3.1. DTD (Document Type Definition)

Un DTD define la estructura de un documento con una sintaxis propia.

Ejemplo de DTD interno:

<!DOCTYPE curso [
    <!ELEMENT curso (nombre, centro, alumnos)>
    <!ELEMENT nombre (#PCDATA)>
    <!ELEMENT centro (#PCDATA)>
    <!ELEMENT alumnos (alumno+)>
    <!ELEMENT alumno (nombre, apellidos, nota)>
    <!ELEMENT apellidos (#PCDATA)>
    <!ELEMENT nota (#PCDATA)>
]>

<curso>
    <nombre>Lenguajes de Marcas</nombre>
    <centro>Academia San Roque</centro>
    <alumnos>
        <!-- ... -->
    </alumnos>
</curso>
  • #PCDATA significa “Parsed Character Data”, es decir, texto.
  • alumno+ indica uno o más elementos <alumno>.

3.2. XML Schema (XSD)

XML Schema es más potente que DTD y está escrito en XML.

Ejemplo (versión simplificada):

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

    <xs:element name="curso">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="nombre" type="xs:string" />
                <xs:element name="centro" type="xs:string" />
                <xs:element name="alumnos">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="alumno" maxOccurs="unbounded">
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="nombre" type="xs:string" />
                                        <xs:element name="apellidos" type="xs:string" />
                                        <xs:element name="nota" type="xs:decimal" />
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

</xs:schema>

XML Schema permite especificar tipos de datos (xs:string, xs:decimal, xs:date, etc.), rangos, patrones, etc.

4. XPath: el lenguaje para navegar por XML

Antes de entrar en XSLT, necesitamos una herramienta clave: XPath.

XPath es un lenguaje para seleccionar partes de un documento XML, similar a cómo usamos rutas de archivos en un sistema de directorios.

4.1. Conceptos básicos

  • El documento XML se ve como un árbol de nodos:
    • Nodo raíz.
    • Elementos.
    • Atributos.
    • Nodos de texto.
  • XPath usa expresiones para llegar a ciertos nodos.

Ejemplos básicos (suponiendo el XML de <curso>):

  • /curso → selecciona el elemento raíz <curso>.
  • /curso/alumnos/alumno → todos los elementos <alumno>.
  • //alumno → todos los <alumno>, estén donde estén.
  • //alumno[nombre="Laura"] → alumno cuyo <nombre> sea “Laura”.
  • //alumno[@id="A001"] → alumno con atributo id="A001".

4.2. Ejes habituales

  • / → desde la raíz.
  • // → en cualquier parte del documento (búsqueda recursiva).
  • . → nodo actual.
  • .. → nodo padre.
  • @ → atributo.

Ejemplos:

  • @id → atributo id del nodo actual.
  • ./nombre → hijo <nombre> del nodo actual.
  • ../nombre → <nombre> del nodo padre.

XPath se usa intensivamente en XSLT para indicar sobre qué parte del XML queremos actuar.

5. Introducción a XSLT

5.1. ¿Qué es XSLT?

XSLT (eXtensible Stylesheet Language Transformations) es un lenguaje basado en XML diseñado para transformar documentos XML.

Con XSLT podemos:

  • Transformar XML en HTML.
  • Transformar XML en otro XML distinto.
  • Generar documentos de texto plano (por ejemplo, un CSV) a partir de XML.

XSLT forma parte de la familia XSL:

  • XSLT: el lenguaje de transformación.
  • XPath: el lenguaje de selección de nodos.
  • XSL-FO: lenguaje para formateo avanzado (PDF, impresión, etc.).

5.2. Cómo funciona XSLT (visión general)

La idea básica es:

  1. Tenemos un documento XML de entrada.
  2. Tenemos una hoja de estilos XSLT (también es XML).
  3. Un procesador XSLT aplica las transformaciones definidas en la hoja de estilos al documento de entrada.
  4. El resultado es un documento de salida (HTML, XML, texto…).

Gráficamente:

XML de entrada + Hoja XSLT → [Procesador XSLT] → Salida (HTML, XML, texto...)

5.3. Ejemplo mínimo de XSLT

Supongamos el XML de alumnos:

<?xml version="1.0" encoding="UTF-8"?>
<curso>
    <nombre>Lenguajes de Marcas</nombre>
    <centro>Academia San Roque</centro>
    <alumnos>
        <alumno>
            <nombre>Laura</nombre>
            <apellidos>Pérez García</apellidos>
            <nota>8.5</nota>
        </alumno>
        <alumno>
            <nombre>Carlos</nombre>
            <apellidos>Ruiz Martín</apellidos>
            <nota>7.0</nota>
        </alumno>
    </alumnos>
</curso>

Y una hoja XSLT muy sencilla que genera una página HTML:

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

    <xsl:template match="/">
        <html>
            <head>
                <title>Listado de alumnos</title>
            </head>
            <body>
                <h1>Listado de alumnos</h1>
                <ul>
                    <xsl:for-each select="curso/alumnos/alumno">
                        <li>
                            <xsl:value-of select="nombre" />
                            <xsl:text> </xsl:text>
                            <xsl:value-of select="apellidos" />
                            <xsl:text> - Nota: </xsl:text>
                            <xsl:value-of select="nota" />
                        </li>
                    </xsl:for-each>
                </ul>
            </body>
        </html>
    </xsl:template>

</xsl:stylesheet>

El resultado de aplicar esta hoja al XML será un documento HTML con una lista desordenada (<ul>) de alumnos.

6. Estructura básica de una hoja XSLT

Una hoja XSLT es también un documento XML. Su estructura básica es:

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

    <!-- Aquí van las plantillas (templates) -->

</xsl:stylesheet>

Elementos clave:

  • <xsl:stylesheet> o <xsl:transform>: elemento raíz de la hoja XSLT.
  • Atributo version: versión de XSLT (1.0, 2.0, 3.0…; lo más tradicional en FP es 1.0).
  • xmlns:xsl="http://www.w3.org/1999/XSL/Transform": declara el espacio de nombres XSLT.

Dentro del xsl:stylesheet se definen principalmente plantillas (<xsl:template>), que describen cómo transformar ciertos nodos del XML.

7. Plantillas (xsl:template) y flujo de ejecución

7.1. xsl:template y el atributo match

Una plantilla define qué hacer con los nodos que coinciden con una expresión XPath dada en match.

Ejemplo:

<xsl:template match="/">
    <!-- Qué hacer con el nodo raíz -->
</xsl:template>

Otro ejemplo:

<xsl:template match="alumno">
    <p>
        <xsl:value-of select="nombre" />
        <xsl:text> </xsl:text>
        <xsl:value-of select="apellidos" />
    </p>
</xsl:template>
  • Esta plantilla se aplicará a cada elemento <alumno> del XML.

7.2. xsl:apply-templates

<xsl:apply-templates> le dice al procesador XSLT que busque plantillas para los nodos seleccionados y las aplique.

Ejemplo típico:

<xsl:template match="/">
    <html>
        <body>
            <h1>Alumnos</h1>
            <xsl:apply-templates select="curso/alumnos/alumno" />
        </body>
    </html>
</xsl:template>

<xsl:template match="alumno">
    <p>
        <xsl:value-of select="nombre" />
        <xsl:text> </xsl:text>
        <xsl:value-of select="apellidos" />
    </p>
</xsl:template>

Flujo:

  1. Se comienza normalmente en la plantilla que hace match="/" (raíz).
  2. Dentro de ella, se llama a <xsl:apply-templates select="curso/alumnos/alumno" />.
  3. Para cada <alumno>, se busca una plantilla match="alumno" y se aplica.

Este modelo se llama procesamiento dirigido por plantillas.

8. Generación de contenido: xsl:value-of, xsl:text y literales

8.1. xsl:value-of

<xsl:value-of> inserta el resultado de evaluar una expresión XPath como texto en la salida.

<xsl:value-of select="nombre" />
  • Toma el contenido de <nombre> del nodo actual.

Ejemplo:

<p>
    <xsl:value-of select="nombre" />
</p>

Si el nodo actual es <alumno>, se mostrará el nombre del alumno.

8.2. xsl:text

<xsl:text> se usa para insertar texto literal en la salida, respetando espacios y saltos de línea.

<xsl:text> - Nota: </xsl:text>
<xsl:value-of select="nota" />

Es útil para añadir espacios, guiones, palabras intermedias, etc.

8.3. Literales XML/HTML en la salida

En XSLT es muy común mezclar elementos literales (HTML, XML) con instrucciones XSLT.

<html>
    <body>
        <h1>Listado de alumnos</h1>
        <ul>
            <xsl:apply-templates select="curso/alumnos/alumno" />
        </ul>
    </body>
</html>

XSLT distingue entre:

  • Elementos en el espacio de nombres XSL (xsl:...) → instrucciones.
  • Elementos literales (sin prefijo o con otro prefijo) → se copian tal cual a la salida (salvo que estén sujetos a otras plantillas).

9. Repeticiones: xsl:for-each

Además de xsl:apply-templates, podemos usar xsl:for-each para iterar manualmente sobre conjuntos de nodos.

<xsl:for-each select="curso/alumnos/alumno">
    <p>
        <xsl:value-of select="nombre" />
        <xsl:text> </xsl:text>
        <xsl:value-of select="apellidos" />
    </p>
</xsl:for-each>

Diferencias entre apply-templates y for-each:

  • xsl:apply-templates delega el procesamiento a otras plantillas.
  • xsl:for-each controla directamente el contenido dentro del bucle.

En muchos ejemplos académicos se usa xsl:for-each porque es más parecido a un bucle clásico, pero en diseños grandes se suele preferir xsl:apply-templates porque separa mejor responsabilidades.

10. Condiciones: xsl:if y xsl:choose

10.1. xsl:if

Permite ejecutar código solo si se cumple una condición XPath.

<xsl:if test="nota &gt;= 5">
    <p>Aprobado</p>
</xsl:if>
  • test es una expresión XPath que debe devolver verdadero o falso.

10.2. xsl:choose (if-else-if)

<xsl:choose> se utiliza cuando hay varios casos posibles.

<xsl:choose>
    <xsl:when test="nota &gt;= 9">
        <p>Sobresaliente</p>
    </xsl:when>
    <xsl:when test="nota &gt;= 7">
        <p>Notable</p>
    </xsl:when>
    <xsl:when test="nota &gt;= 5">
        <p>Aprobado</p>
    </xsl:when>
    <xsl:otherwise>
        <p>Suspenso</p>
    </xsl:otherwise>
</xsl:choose>

Este patrón es equivalente a un if - else if - else en lenguajes de programación clásicos.

11. Variables y parámetros en XSLT

11.1. xsl:variable

Permite guardar valores (nodos, números, cadenas) para reutilizarlos.

<xsl:variable name="mediaAprobado" select="5" />
  • El atributo name define el nombre de la variable (sin $, el $ se usa solo al referenciarla).
  • Para usar la variable: $mediaAprobado.

Ejemplo más útil:

<xsl:variable name="totalAlumnos" select="count(/curso/alumnos/alumno)" />
<p>Número de alumnos: <xsl:value-of select="$totalAlumnos" /></p>

También se pueden definir variables con contenido literal:

<xsl:variable name="titulo">
    <xsl:text>Listado completo de alumnos</xsl:text>
</xsl:variable>

<h1><xsl:value-of select="$titulo" /></h1>

11.2. xsl:param

xsl:param se usa para recibir parámetros en plantillas. Es muy útil cuando se invocan plantillas desde otras con xsl:call-template o desde el procesador XSLT.

<xsl:template name="mostrarNota">
    <xsl:param name="notaAlumno" />
    <p>Nota del alumno: <xsl:value-of select="$notaAlumno" /></p>
</xsl:template>

Y para llamar a esa plantilla:

<xsl:call-template name="mostrarNota">
    <xsl:with-param name="notaAlumno" select="nota" />
</xsl:call-template>

12. Plantillas nombradas y reutilización de código

Además de match, una plantilla puede tener un nombre con el atributo name. Esto permite llamarla explícitamente.

<xsl:template name="cabeceraHTML">
    <head>
        <meta charset="UTF-8" />
        <title>Informe de alumnos</title>
    </head>
</xsl:template>

Luego podemos usar:

<xsl:call-template name="cabeceraHTML" />

Esto facilita reutilizar estructuras comunes.

Podemos combinar name y match, aunque en muchos casos se usan por separado según la necesidad.

13. Modos (modes) y prioridad de plantillas

Cuando queremos tener distintas formas de procesar el mismo tipo de nodo, podemos usar modos (mode).

<xsl:template match="alumno" mode="lista">
    <li>
        <xsl:value-of select="nombre" />
        <xsl:text> </xsl:text>
        <xsl:value-of select="apellidos" />
    </li>
</xsl:template>

<xsl:template match="alumno" mode="tabla">
    <tr>
        <td><xsl:value-of select="nombre" /></td>
        <td><xsl:value-of select="apellidos" /></td>
        <td><xsl:value-of select="nota" /></td>
    </tr>
</xsl:template>

Para aplicar uno u otro modo:

<xsl:apply-templates select="curso/alumnos/alumno" mode="lista" />

o bien:

<xsl:apply-templates select="curso/alumnos/alumno" mode="tabla" />

Prioridad de plantillas

Si varias plantillas pueden aplicarse al mismo nodo, XSLT decide cuál usar:

  • A partir de la especificidad del patrón (match).
  • Y/o de la prioridad explícita (priority).
<xsl:template match="alumno" priority="1">
    <!-- ... -->
</xsl:template>

La plantilla con mayor prioridad se aplica sobre las demás.

14. Transformaciones típicas

14.1. De XML a HTML (listado en tabla)

Supongamos que queremos generar una tabla HTML con los alumnos.

<xsl:template match="/">
    <html>
        <head>
            <title>Notas de alumnos</title>
            <meta charset="UTF-8" />
        </head>
        <body>
            <h1>Notas de alumnos</h1>
            <table border="1">
                <tr>
                    <th>Nombre</th>
                    <th>Apellidos</th>
                    <th>Nota</th>
                    <th>Estado</th>
                </tr>
                <xsl:for-each select="curso/alumnos/alumno">
                    <tr>
                        <td><xsl:value-of select="nombre" /></td>
                        <td><xsl:value-of select="apellidos" /></td>
                        <td><xsl:value-of select="nota" /></td>
                        <td>
                            <xsl:choose>
                                <xsl:when test="nota &gt;= 5">Aprobado</xsl:when>
                                <xsl:otherwise>Suspenso</xsl:otherwise>
                            </xsl:choose>
                        </td>
                    </tr>
                </xsl:for-each>
            </table>
        </body>
    </html>
</xsl:template>

Resultado: una página HTML con una tabla de alumnos y su estado.

14.2. De XML a otro XML (normalización)

Podemos transformar un XML en otro XML con estructura distinta.

XML de entrada (simplificado):

<curso>
    <alumnos>
        <alumno>
            <nombre>Laura</nombre>
            <nota>8.5</nota>
        </alumno>
        <alumno>
            <nombre>Carlos</nombre>
            <nota>7.0</nota>
        </alumno>
    </alumnos>
</curso>

Queremos un XML de salida con esta forma:

<informe>
    <estudiante nombre="Laura" nota="8.5" />
    <estudiante nombre="Carlos" nota="7.0" />
</informe>

Hoja XSLT:

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

    <xsl:output method="xml" indent="yes" />

    <xsl:template match="/curso/alumnos">
        <informe>
            <xsl:for-each select="alumno">
                <estudiante>
                    <xsl:attribute name="nombre">
                        <xsl:value-of select="nombre" />
                    </xsl:attribute>
                    <xsl:attribute name="nota">
                        <xsl:value-of select="nota" />
                    </xsl:attribute>
                </estudiante>
            </xsl:for-each>
        </informe>
    </xsl:template>

</xsl:stylesheet>

Observa:

  • Usamos xsl:output para indicar que la salida será XML y que queremos indentación.
  • Usamos xsl:attribute para construir atributos dinámicamente.

14.3. De XML a texto (por ejemplo, CSV)

Suponiendo el mismo XML de alumnos, podríamos generar un CSV:

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

    <xsl:output method="text" encoding="UTF-8" />

    <xsl:template match="/">
        <!-- Cabecera CSV -->
        <xsl:text>Nombre;Apellidos;Nota&#10;</xsl:text>
        <!-- Filas -->
        <xsl:for-each select="curso/alumnos/alumno">
            <xsl:value-of select="nombre" />
            <xsl:text>;</xsl:text>
            <xsl:value-of select="apellidos" />
            <xsl:text>;</xsl:text>
            <xsl:value-of select="nota" />
            <xsl:text>&#10;</xsl:text> <!-- Salto de línea -->
        </xsl:for-each>
    </xsl:template>

</xsl:stylesheet>
  • method="text" indica que la salida no es XML ni HTML, sino texto plano.
  • &#10; es un salto de línea.

15. La transformación de identidad (identity transform)

Un patrón muy común en XSLT es la transformación de identidad, que copia el documento de entrada a la salida, permitiendo modificar solo ciertas partes.

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

    <!-- 1. Plantilla de identidad -->
    <xsl:template match="@*|node()">
        <xsl:copy>
            <xsl:apply-templates select="@*|node()" />
        </xsl:copy>
    </xsl:template>

    <!-- 2. Plantilla específica para modificar algo -->
    <xsl:template match="nota">
        <nota>
            <xsl:value-of select="round(number(.) * 2) div 2" />
        </nota>
    </xsl:template>

</xsl:stylesheet>

Explicación:

  1. La primera plantilla dice: para cualquier nodo o atributo (@*|node()), cópialo tal cual y sigue aplicando plantillas a sus hijos/atributos.
  2. La segunda plantilla redefine cómo se procesan las etiquetas <nota> (por ejemplo, redondeando las notas).

Resultado: el XML de salida será igual al de entrada, excepto por las <nota>, que habrán sido transformadas.

16. Agrupaciones (introducción al método de Muenchian)

En XSLT 1.0 no existe una instrucción de agrupación directa, pero se usa un patrón conocido como agrupación Muenchian para agrupar nodos por un determinado criterio.

Ejemplo: supongamos que tenemos alumnos con un elemento <grupo> y queremos generar un listado agrupado por grupo.

XML de entrada (simplificado):

<curso>
    <alumnos>
        <alumno>
            <nombre>Laura</nombre>
            <grupo>A</grupo>
        </alumno>
        <alumno>
            <nombre>Carlos</nombre>
            <grupo>B</grupo>
        </alumno>
        <alumno>
            <nombre>Ana</nombre>
            <grupo>A</grupo>
        </alumno>
    </alumnos>
</curso>

XSLT (versión básica de Muenchian):

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

    <!-- Definimos una clave: agrupa alumnos por el valor de <grupo> -->
    <xsl:key name="alumnosPorGrupo" match="alumno" use="grupo" />

    <xsl:template match="/curso/alumnos">
        <html>
            <body>
                <!-- Seleccionamos solo el primer alumno de cada grupo -->
                <xsl:for-each select="alumno[generate-id() = generate-id(key('alumnosPorGrupo', grupo)[1])]">
                    <h2>Grupo <xsl:value-of select="grupo" /></h2>
                    <ul>
                        <!-- Para cada grupo, listamos todos los alumnos -->
                        <xsl:for-each select="key('alumnosPorGrupo', grupo)">
                            <li><xsl:value-of select="nombre" /></li>
                        </xsl:for-each>
                    </ul>
                </xsl:for-each>
            </body>
        </html>
    </xsl:template>

</xsl:stylesheet>

Este ejemplo es avanzado para FP básica, pero es importante conocer que XSLT permite también tareas complejas como la agrupación.

17. Herramientas para ejecutar XSLT

En la práctica, para aplicar hojas XSLT a documentos XML podemos usar diferentes herramientas:

  1. Navegadores web (para XSLT 1.0):
    • Muchos navegadores son capaces de aplicar XSLT directamente si se indica en el XML.
    • Se añade una instrucción de procesamiento en el XML: <?xml-stylesheet type="text/xsl" href="transformacion.xsl"?> Cuando abrimos el XML en el navegador, este aplica la transformación y muestra el resultado (normalmente HTML).
  2. Procesadores XSLT independientes:
    • xsltproc (en Linux/Unix).
    • Saxon (muy usado, soporta XSLT 2.0 y 3.0 según la versión).
    Ejemplo con xsltproc: xsltproc transformacion.xsl datos.xml > salida.html
  3. Entornos de desarrollo y editores:
    • Algunos IDEs y editores XML permiten ejecutar transformaciones XSLT con un clic y ver el resultado.

18. Buenas prácticas con XML y XSLT

18.1. Buenas prácticas en XML

  • Mantener un diseño coherente: misma convención para nombres de etiquetas y atributos.
  • Usar nombres significativos y claros.
  • Indentar correctamente el documento para facilitar la lectura.
  • Validar contra un DTD o XSD cuando el intercambio de datos sea crítico.
  • Evitar mezclar datos y presentación: XML para datos, CSS/HTML para presentación (a través de XSLT u otros medios).

18.2. Buenas prácticas en XSLT

  • Separar las plantillas por responsabilidad (por ejemplo, una plantilla para la cabecera, otra para el cuerpo, etc.).
  • Preferir xsl:apply-templates frente a xsl:for-each cuando sea razonable, para mantener el estilo dirigido por plantillas.
  • Documentar la hoja XSLT con comentarios explicando las partes más complejas.
  • Usar xsl:output para controlar el formato de salida (HTML, XML, texto).
  • Probar la transformación con varios documentos de entrada (casos normales, vacíos, extremos…).

19. Errores habituales y cómo evitarlos

  1. Documento XML no bien formado:
    • Etiquetas sin cerrar, mal anidadas, atributos sin comillas…
    • Solución: validar el XML con un parser o editor que marque errores.
  2. Expresiones XPath incorrectas:
    • Olvidar el contexto actual o usar rutas absolutas cuando deberían ser relativas.
    • Solución: revisar la estructura del XML y probar XPath en herramientas de prueba.
  3. No se aplica la plantilla esperada:
    • El patrón match no coincide con el nodo o hay otra plantilla con más prioridad.
    • Solución: revisar match, mode y prioridades; usar mensajes de depuración (xsl:message).
  4. Problemas con espacios de nombres (namespaces):
    • Intentar seleccionar elementos sin tener en cuenta su prefijo/namespace.
    • Solución: declarar correctamente los namespaces en la hoja XSLT y usar los prefijos adecuados en XPath.
  5. Salida HTML mal formada:
    • Olvidar cerrar etiquetas o mezclar mal elementos HTML.
    • Solución: recordar que aunque la salida sea HTML, XSLT sigue siendo XML y debe ser bien formado.

20. Resumen final

En estos apuntes hemos recorrido, con detalle, las bases necesarias para trabajar con XML y XSLT:

  1. XML como lenguaje de marcado estructurado, sus reglas de sintaxis, elementos, atributos, entidades y namespaces.
  2. Validación mediante DTD y XML Schema para garantizar la calidad de los datos.
  3. XPath como lenguaje fundamental para seleccionar nodos dentro de un documento XML.
  4. XSLT como lenguaje de transformación que permite convertir XML en HTML, otros XML o texto.
  5. Estructura de una hoja XSLT: xsl:stylesheet, plantillas con match, apply-templates, for-each, condiciones, variables, parámetros, modos…
  6. Ejemplos prácticos de transformaciones típicas:
    • XML → HTML.
    • XML → XML.
    • XML → texto.
  7. Patrones más avanzados como la transformación de identidad y la agrupación.
  8. Herramientas, buenas prácticas y errores comunes.

Con esta base teórica y práctica, el alumnado de la Academia San Roque dispone de un material de referencia completo para:

  • Entender ejercicios de clase.
  • Preparar exámenes de la asignatura de Lenguajes de Marcas.
  • Afrontar situaciones reales de trabajo donde se utilice XML y XSLT.

A partir de aquí, es recomendable practicar con:

  • Pequeños documentos XML propios (por ejemplo, listas de productos, alumnos, pedidos…).
  • Diferentes hojas de estilos XSLT que generen HTML, XML y texto.

La combinación de teoría y práctica consolidará el manejo de estas tecnologías, que continúan siendo fundamentales en muchos entornos profesionales.

Contenido restringido

Acceso de usuarios existentes
   
Registro de un nuevo usuario
*Campo necesario

Categories:

Informática

Tags:

Sin etiqueta

Comments are closed

Estado de acceso
ESTADO DE ACCESO
TRADUCTORES
¡Síguenos!
COMPARTENOS
Insert math as
Block
Inline
Additional settings
Formula color
Text color
#333333
Type math using LaTeX
Preview
\({}\)
Nothing to preview
Insert
error: CONTENIDO PROTEGIDO