Tutorial XSLT, realiza transformaciones sobre XML

En este tutorial de XSLT (Extensible Stylesheet Language Transformations), exploraremos una poderosa herramienta para transformar y presentar documentos XML. XSLT es un lenguaje de programación declarativo que nos permite realizar manipulaciones complejas en la estructura y contenido de un documento XML.

Contenidos del artículo

El Tutorial de XSLT es una excelente continuación después de aprender sobre XML, DTD, XSD y XPath. En este tutorial, aprenderás los conceptos fundamentales de XSLT y cómo utilizarlo para realizar transformaciones en documentos XML. Veremos cómo utilizar las plantillas, selectores, funciones y otros elementos clave de XSLT para generar resultados personalizados.

Además, exploraremos las capacidades de XSLT para aplicar estilos y formatos a documentos XML, permitiéndonos crear presentaciones visuales atractivas y consistentes.

Al final de este tutorial, tendrás un conocimiento sólido de XSLT y estarás preparado para utilizarlo en tus propios proyectos de transformación y presentación de datos XML.

1. Tutorial XSLT: Introducción

XSLT (Extensible Stylesheet Language Transformations, Lenguaje de Hoja de estilo Extensible o Ampliado) es un lenguaje de transformación utilizado para manipular y presentar documentos XML. Permite modificar la estructura y el contenido de los datos XML, aplicar estilos y generar diferentes formatos de salida. Con XSLT, puedes crear poderosas transformaciones para adaptar tus datos XML según tus necesidades.

2. Hoja de estilo XSLT

Las hojas de estilo XSLT se construyen sobre estructuras denominadas plantillas (templates). Una plantilla especifica qué es lo que hay que buscar en el árbol de origen y qué es lo que hay que poner en el árbol de resultado. XSLT está escrito en XML, lo que significa que existen elementos y atributos XSLT especiales que se utilizan para crear las hojas de estilo en formato «.xsl».

3. Cómo crear una hoja de estilo XSL

Para crear una hoja de estilo XSLT válida, debes asegurarte de que esté bien formada y tenga una declaración XML al comienzo. El elemento raíz de la hoja de estilo XSLT es el «xsl:stylesheet«, y debe tener el alias «xsl» asociado al espacio de nombres para hojas de estilo XSLT. Esto se logra mediante la definición de un prefijo «xsl» que apunta a la URL «http://www.w3.org/1999/XSL/Transform». Al utilizar este prefijo en los elementos reservados por la especificación XSLT, se garantiza que la hoja de estilo esté correctamente definida.

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

Dentro del elemento raíz xsl:stylesheet se especifican las reglas de transformación utilizando el elemento xsl:template. Estas reglas determinan qué elementos del documento XML se transformarán y cómo se realizará dicha transformación.

La regla de transformación se aplica al elemento indicado por el atributo «match» mediante una expresión XPath (para conocer este tipo de expresiones realiza el tutorial XPath.

Por tanto, entre las etiquetas de inicio y fin del elemento «xsl:template» se especifica la transformación que se debe realizar, es decir, qué texto y marcas se agregarán al documento resultante cada vez que se encuentre una instancia del elemento indicado en el atributo «match» en el documento de origen. Ejemplo:

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

Hay que tener en cuenta que en XSLT lo que se ponga en el atributo match se convierte en el nodo de contexto. Esto significa que todas las expresiones XPATH son relativas a ese nodo.

Por otra parte, una hoja de estilo XSL se puede asociar con un documento XML:

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="styles.xsl"?>
<root>
  <!-- XML document content here -->
</root>

4. Ejemplo de transformación XSLT

La regla <xsl:template match="/"> se ejecuta cuando se encuentra el elemento raíz del documento document.xsl. Dentro de esta regla, podemos incluir llamadas a otras reglas definidas en la hoja de estilo utilizando el elemento <xsl:apply-templates select="...">. El atributo select especifica el nombre del elemento asociado a la regla que queremos aplicar. Esto nos permite tener un control preciso sobre el orden de ejecución de las reglas.

El código XSLT tomará el archivo XML y generará un documento HTML que muestra una lista de productos con su nombre y precio.

Archivo XML:

<?xml version="1.0"?>
<products>
  <product>
    <name>T-shirt</name>
    <price>20</price>
  </product>
  <product>
    <name>Pants</name>
    <price>30</price>
  </product>
  <product>
    <name>Shoes</name>
    <price>50</price>
  </product>
</products>

Archivo XSL:

<?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>Product List</title>
      </head>
      <body>
        <h1>Product List</h1>
        <ul>
          <xsl:for-each select="products/product">
            <li>
              <xsl:value-of select="name" />
              <span> - </span>
              <xsl:value-of select="price" />
              <span>€</span>
            </li>
          </xsl:for-each>
        </ul>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>

Salida generada:

<html>
  <head>
    <title>Product List</title>
  </head>
  <body>
    <h1>Product List</h1>
    <ul>
      <li>T-shirt - 20€</li>
      <li>Pants - 30€</li>
      <li>Shoes - 50€</li>
    </ul>
  </body>
</html>

4.1. Ejemplos de valores del atributo match

El atributo match en XSLT puede tener diferentes valores, dependiendo de cómo deseamos seleccionar los nodos del documento XML de origen para aplicar las reglas de transformación. Algunos ejemplos de valores comunes para el atributo match son:

Seleccionar todos los nodos con un nombre concreto: match="book" seleccionará todos los nodos <book> en el documento XML de origen.
Coger un nodo específico: match="books/book" seleccionará todos los nodos <book> que son hijos directos de un nodo <books>.
Seleccionar todos los nodos descendientes, es decir, los nodos hijos, los hijos de los hijos y así sucesivamente, de un nodo en el camino de búsqueda: match="//books"
Seleccionar nodos con base en condiciones específicas. Por ejemplo, match="book[@category='fiction']" seleccionará todos los nodos <book> que tengan el atributo category con el valor «fiction».
Elegir múltiples nodos. match="book/*" seleccionará todos los elementos hijos directos de los nodos <book>.
Seleccionar nodos con un atributo específico: match="book[@lang='en']" seleccionará todos los nodos <book> que tengan el atributo lang con el valor «en».
Escoger nodos con contenido específico: match="book[text()='Harry Potter']" seleccionará todos los nodos <book> que contengan el texto «Harry Potter».
Tomar nodos con un atributo que comienza con un valor específico: match="book[starts-with(@id, 'B')] seleccionará todos los nodos <book> que tengan un atributo id que comience con la letra «B».
Seleccionar nodos con un atributo que contiene un valor específico: match="book[contains(@title, 'XML')]" seleccionará todos los nodos <book> cuyo atributo title contenga la palabra «XML».
Elegir nodos con un atributo que coincide con un patrón específico: match="book[@isbn='ISBN\d{10}']" seleccionará todos los nodos <book> cuyo atributo isbn coincida con el patrón «ISBN» seguido de 10 dígitos.

Estos son solo algunos ejemplos de los valores que puede tomar el atributo match. Te recomendamos hacer el tutorial de XPath para ver más ejemplos.

5. Herramientas para realizar una transformación XSLT

Existen varias herramientas disponibles para realizar transformaciones XSLT:

Herramientas en línea: Hay varios servicios en línea que permiten realizar transformaciones XSLT sin necesidad de instalar software adicional, como por ejemplo XSLT Transformer (freeformatter.com/xsl-transformer.html).
Línea de comandos: Muchas plataformas y lenguajes de programación incluyen utilidades de línea de comandos para ejecutar transformaciones XSLT. Algunas de las opciones populares son Saxon, Xalan y xsltproc.
Editores de código: Muchos editores de código ofrecen herramientas y extensiones para facilitar el desarrollo y prueba de transformaciones XSLT. Algunos editores populares son Visual Studio Code con la extensión XML Tools, Eclipse con el complemento XML Editor, y Oxygen XML Editor.
Programas específicos: También existen programas específicos diseñados para crear y ejecutar transformaciones XSLT, como por ejemplo Altova XMLSpy.

6. Elementos

Existen varios elementos XSLT que se pueden insertar en la plantilla o template para realizar las distintas acciones. A continuación se muestra una tabla con los elementos más utilizados en XSLT:

En la siguiente tabla se muestran algunos de los elementos más comunes utilizados en XSLT, pero XSLT tiene una amplia gama de elementos y funcionalidades más avanzadas.:

Elemento	Descripción
`<xsl:stylesheet>`	Elemento raíz de la hoja de estilo XSLT
`<xsl:template>`	Define una regla de transformación para un elemento específico
`<xsl:apply-templates>`	Aplica las reglas de transformación a los elementos seleccionados
`<xsl:value-of>`	Recupera el valor de un elemento o atributo
`<xsl:for-each>`	Itera sobre un conjunto de elementos
`<xsl:if>`	Ejecuta una transformación si se cumple una condición
`<xsl:choose>`	Permite realizar una selección condicional
`<xsl:sort>`	Ordena los elementos seleccionados
`<xsl:attribute>`	Agrega un atributo a un elemento
`<xsl:comment>`	Inserta un comentario en el resultado de la transformación
`<xsl:text>`	Agrega texto literal en el resultado de la transformación
`<xsl:variable>`	Declara una variable
`<xsl:import>`	Importa una hoja de estilo externa
`<xsl:output>`	Define la configuración de salida del resultado
`<xsl:when>`	Declara una condición para una selección condicional
`<xsl:otherwise>`	Define una opción por defecto en una selección condicional
`<xsl:copy>`	Copia el contenido de un elemento o nodo

Tabla 1. Elementos más comunes utilizados en XSLT

6.1. Elemento <xsl:value-of>

El elemento <xsl:value-of> se utiliza en una hoja de estilo XSL para recuperar y mostrar el valor de un nodo o expresión en el documento XML resultante de la transformación.

Su sintaxis básica es la siguiente:

<xsl:value-of select="expresión"/>

Donde:

select es un atributo obligatorio que especifica la expresión XPath que indica qué valor se debe recuperar.
La expresión puede ser el nombre de un elemento, un camino de acceso a un nodo o una función XPath.

Ejemplo para recoger el contenido de una etiqueta:
Archivo XML:

<book>
  <title>Harry Potter and the Sorcerer's Stone</title>
  <author>J.K. Rowling</author>
</book>

Podemos usar <xsl:value-of> para mostrar el título del libro en la transformación XSLT:

<xsl:value-of select="book/title"/>

Salida:

Harry Potter and the Sorcerer's Stone

Ejemplo para mostrar el valor de un atributo:

En este caso, dentro de la plantilla que coincide con el elemento <alumno>, se utilizan las expresiones @nombre, @edad y @curso en los elementos <xsl:value-of> para mostrar el valor de los atributos correspondientes dentro de elementos <p>. Cada <xsl:value-of> recupera el valor del atributo indicado utilizando la sintaxis @nombreAtributo.

Archivo XML:

<alumno nombre="Severo Ochoa" edad="20" curso="Informática" />

Archivo XSL:

<xsl:template match="alumno">
  <div>
    <h2>Información del alumno:</h2>
    <p>Nombre: <xsl:value-of select="@nombre" /></p>
    <p>Edad: <xsl:value-of select="@edad" /></p>
    <p>Curso: <xsl:value-of select="@curso" /></p>
  </div>
</xsl:template>

Salida:

<div>
   <h2>Información del alumno:</h2>
   <p>Nombre: Severo Ochoa</p>
   <p>Edad: 20</p>
   <p>Curso: Informática</p>
</div>

6.2. Elemento <xsl:sort>

Correcto, para ordenar los contenidos en XSLT se utiliza el elemento <xsl:sort>, que se coloca como hijo de <xsl:apply-templates>. El elemento <xsl:sort> acepta dos atributos:

select: que especifica el nombre del elemento que se utilizará como criterio de ordenación.
order: que indica si se debe utilizar un orden ascendente (ascending) o descendente (descending).

Ejemplo:

En este caso, se aplica la plantilla a todos los elementos <ciudad>, y se realiza la ordenación según el elemento <nombre>, en orden descendente. Esto garantiza que las ciudades se mostrarán en el resultado final en orden alfabético descendente por su nombre.

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <xsl:apply-templates select="//ciudad">
      <xsl:sort select="nombre" order="descending" />
    </xsl:apply-templates>
  </xsl:template> 
  <xsl:template match="ciudad">
    <p>
      <xsl:value-of select="nombre" />
    </p>
  </xsl:template>
</xsl:stylesheet>

Archivo XML:

<ciudades>
  <ciudad>
    <nombre>Madrid</nombre>
    <poblacion>3000000</poblacion>
  </ciudad>
  <ciudad>
    <nombre>Barcelona</nombre>
    <poblacion>2000000</poblacion>
  </ciudad>
  <ciudad>
    <nombre>Valencia</nombre>
    <poblacion>1000000</poblacion>
  </ciudad>
</ciudades>

Salida:

<p>Valencia</p>
<p>Madrid</p>
<p>Barcelona</p>

6.3. Elemento <xsl:if>

El elemento <xsl:if> se utiliza en XSLT para realizar una evaluación condicional y controlar si ciertas instrucciones deben ejecutarse o no en función de una expresión booleana.

La sintaxis básica del elemento <xsl:if> es la siguiente:

<xsl:if test="expresion">
  <!-- Instrucciones a ejecutar si la expresión es verdadera -->
</xsl:if>

La expresión en el atributo test es evaluada y si es verdadera, las instrucciones dentro del bloque <xsl:if> se ejecutan. Si la expresión es falsa, las instrucciones se omiten.

1.Ejemplo:

<xsl:template match="student">
  <xsl:if test="grade &gt;= 80">
    <p>
      <xsl:value-of select="name" /> has passed the exam with a grade of <xsl:value-of select="grade" />.
    </p>
  </xsl:if>
</xsl:template>

En este ejemplo, si el estudiante tiene una calificación igual o superior a 80, se mostrará un párrafo indicando que ha aprobado el examen junto con su nombre y calificación. Si la calificación es inferior a 80, el bloque <xsl:if> se omitirá y no se mostrará ningún resultado.

2. Ejemplo:

<xsl:template match="product">
  <xsl:if test="price &lt; 50">
    <div class="sale">
      <h2>
        <xsl:value-of select="name" />
      </h2>
      <p>
        On sale for $<xsl:value-of select="price" />!
      </p>
    </div>
  </xsl:if>
</xsl:template>

En este ejemplo, se aplica una transformación a los elementos «product». Dentro del bloque <xsl:if>, se verifica si el precio del producto es menor que 50. Si se cumple esa condición, se genera un <div> con la clase «sale» que muestra el nombre del producto y su precio en un formato especial para promociones.

Si la condición del <xsl:if> no se cumple, es decir, si el precio del producto es igual o mayor a 50, entonces el bloque de instrucciones dentro del <xsl:if> se omite y no se generará ninguna salida correspondiente al producto en oferta.

3. Ejemplo:

<xsl:template match="person">
  <xsl:if test="age = 30">
    <div class="selected">
      <h2>
        <xsl:value-of select="name" />
      </h2>
      <p>
        Age: <xsl:value-of select="age" />
      </p>
    </div>
  </xsl:if>
</xsl:template>

En este ejemplo, se aplica una transformación a los elementos «person». Dentro del bloque <xsl:if>, se verifica si el atributo «age» tiene un valor igual a 30. Si se cumple esa condición, se genera un <div> con la clase «selected» que muestra el nombre y la edad de la persona.

Si la condición del <xsl:if> no se cumple, es decir, si el atributo «age» no tiene un valor igual a 30, entonces el bloque de instrucciones dentro del <xsl:if> se omite y no se generará ninguna salida correspondiente a esa persona en particular.

6.4. Elemento <xsl:variable>

El elemento <xsl:variable> en XSLT se utiliza para declarar y asignar valores a variables dentro de la transformación. Estas variables pueden contener valores estáticos o pueden ser calculadas a partir de expresiones XPath.

La sintaxis básica para declarar una variable es la siguiente:

<xsl:variable name="nombreVariable" select="expresionXPath" />

name especifica el nombre de la variable.
select define la expresión XPath que se evaluará y asignará como valor a la variable.

Una vez declarada la variable, puedes utilizar su valor en otros lugares de la transformación utilizando la sintaxis $nombreVariable.

Ejemplo:

Archivo XML:

<?xml version="1.0" encoding="UTF-8"?>
<productos>
  <producto>
    <nombre>Camiseta</nombre>
    <precio>20</precio>
    <descuento>0.1</descuento>
  </producto>
  <producto>
    <nombre>Pantalón</nombre>
    <precio>50</precio>
    <descuento>0.2</descuento>
  </producto>
</productos>

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:template match="producto">
  <xsl:variable name="precio" select="precio" />
  <xsl:variable name="descuento" select="descuento" />
  <xsl:variable name="precioFinal" select="$precio - ($precio * $descuento)" />

  <div>
    <h3>Nombre: <xsl:value-of select="nombre" /></h3>
    <p>Precio: <xsl:value-of select="$precio" /></p>
    <p>Descuento: <xsl:value-of select="$descuento" /></p>
    <p>Precio Final: <xsl:value-of select="$precioFinal" /></p>
  </div>
 </xsl:template>
</xsl:stylesheet>

Salida:

  <div>
   <h3>Nombre: Camiseta</h3>
   <p>Precio: 20</p>
   <p>Descuento: 0.1</p>
   <p>Precio Final: 18</p>
</div>
  <div>
   <h3>Nombre: Pantalón</h3>
   <p>Precio: 50</p>
   <p>Descuento: 0.2</p>
   <p>Precio Final: 40</p>
</div>

En este ejemplo, asumimos que tenemos un elemento <producto> con los subelementos nombre, precio y descuento. Declaramos tres variables: precio, descuento y precioFinal. Luego, utilizamos estas variables para realizar cálculos y mostrar la información del producto, incluyendo el precio final después de aplicar el descuento.

Ten en cuenta que los valores de las variables se calculan una vez y se mantienen constantes dentro del alcance del template donde se definen. Esto significa que si tienes múltiples elementos <producto> en tu XML de origen, las variables se calcularán y utilizarán de forma independiente para cada elemento.

6.5. Elemento <xsl:for-each>

El elemento <xsl:for-each> se utiliza en XSLT para iterar sobre un conjunto de nodos seleccionados y aplicar una transformación a cada uno de ellos.

Ejemplo:

En este ejemplo, se aplica una transformación a los elementos «libro». Dentro del <xsl:for-each>, se selecciona cada elemento «autor» y se muestra su valor usando <xsl:value-of>. De esta manera, se generará un párrafo para cada autor presente en el documento XML.

Archivo XML:

<libros>
  <libro>
    <autor>John Smith</autor>
  </libro>
  <libro>
    <autor>Jane Doe</autor>
  </libro>
  <libro>
    <autor>Michael Johnson</autor>
  </libro>
</libros>

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="libro">
    <xsl:for-each select="autor">
      <p>
        Autor: <xsl:value-of select="." />
      </p>
    </xsl:for-each>
  </xsl:template>
</xsl:stylesheet>

Salida:

  <p>Autor: John Smith</p>
  <p>Autor: Jane Doe</p>
  <p>Autor: Michael Johnson</p>

7. Ejercicios resueltos: Tutorial XSLT

Con este conjunto de ejercicios prácticos resueltos podrás poner en práctica tus habilidades en XSD y comprobar si un archivo XML cumple las reglas definidas en XML Schema.

7.1. Tutorial XSLT. Ejercicio resuelto: Listar empleados

Dado un archivo XML que contiene información sobre empleados, se desea realizar una transformación XSLT para generar una lista ordenada de empleados con sus respectivos nombres y salarios. La lista debe estar ordenada por salario de forma descendente.

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <html>
      <head>
        <title>Lista de Empleados</title>
      </head>
      <body>
        <h1>Lista de Empleados</h1>
        <xsl:apply-templates select="//empleado">
          <xsl:sort select="salario" order="descending" />
        </xsl:apply-templates>
      </body>
    </html>
  </xsl:template>

  <xsl:template match="empleado">
    <p>
      <strong>Nombre: </strong><xsl:value-of select="nombre" /><br />
      <strong>Salario: </strong><xsl:value-of select="salario" />
    </p>
  </xsl:template>
</xsl:stylesheet>

Archivo XML:

<empleados>
  <empleado>
    <nombre>John Doe</nombre>
    <salario>5000</salario>
  </empleado>
  <empleado>
    <nombre>Jane Smith</nombre>
    <salario>7000</salario>
  </empleado>
  <empleado>
    <nombre>Mike Johnson</nombre>
    <salario>4000</salario>
  </empleado>
</empleados>

Salida:

<html>
   <head>
      <title>Lista de Empleados</title>
   </head>
   <body>
      <h1>Lista de Empleados</h1>
      <p>
         <strong>Nombre: </strong>Jane Smith<br/>
         <strong>Salario: </strong>7000</p>
      <p>
         <strong>Nombre: </strong>John Doe<br/>
         <strong>Salario: </strong>5000</p>
      <p>
         <strong>Nombre: </strong>Mike Johnson<br/>
         <strong>Salario: </strong>4000</p>
   </body>
</html>

7.2. Tutorial XSLT. Ejercicio resuelto: Informe de ventas

Se cuenta con un archivo XML que contiene información sobre ventas de productos por categoría. Se desea realizar una transformación XSLT para generar un informe que muestre las ventas totales por categoría, incluyendo el nombre de la categoría y el monto total de ventas.

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <html>
      <head>
        <title>Informe de Ventas por Categoría</title>
      </head>
      <body>
        <h1>Informe de Ventas por Categoría</h1>
        <table>
          <tr>
            <th>Categoría</th>
            <th>Ventas Totales</th>
          </tr>
          <xsl:for-each select="//categoria">
            <xsl:sort select="nombre" />
            <tr>
              <td><xsl:value-of select="nombre" /></td>
              <td><xsl:value-of select="sum(venta)" /></td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>

Archivo XML:

<ventas>
  <categoria>
    <nombre>Electrónica</nombre>
    <venta>1500</venta>
  </categoria>
  <categoria>
    <nombre>Ropa</nombre>
    <venta>800</venta>
  </categoria>
  <categoria>
    <nombre>Libros</nombre>
    <venta>1200</venta>
  </categoria>
</ventas>

Salida:

<html>
   <head>
      <title>Informe de Ventas por Categoría</title>
   </head>
   <body>
      <h1>Informe de Ventas por Categoría</h1>
      <table>
         <tr>
            <th>Categoría</th>
            <th>Ventas Totales</th>
         </tr>
         <tr>
            <td>Electrónica</td>
            <td>1500</td>
         </tr>
         <tr>
            <td>Libros</td>
            <td>1200</td>
         </tr>
         <tr>
            <td>Ropa</td>
            <td>800</td>
         </tr>
      </table>
   </body>
</html>

7.3. Tutorial XSLT. Ejercicio resuelto: Generar catálogo de productos

Se cuenta con un archivo XML que contiene información sobre un catálogo de productos. Cada producto tiene un nombre, una descripción y un precio. Se desea realizar una transformación XSLT para generar un catálogo HTML que muestre todos los productos con su respectiva información.

Archivo XSL:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <html>
      <head>
        <title>Catálogo de Productos</title>
      </head>
      <body>
        <h1>Catálogo de Productos</h1>
        <xsl:apply-templates select="//producto" />
      </body>
    </html>
  </xsl:template>

  <xsl:template match="producto">
    <div class="producto">
      <h2><xsl:value-of select="nombre" /></h2>
      <p><xsl:value-of select="descripcion" /></p>
      <p>Precio: <xsl:value-of select="precio" /></p>
    </div>
  </xsl:template>
</xsl:stylesheet>

Archivo XML:

<catalogo>
  <producto>
    <nombre>Producto 1</nombre>
    <descripcion>Descripción del producto 1</descripcion>
    <precio>10.99</precio>
  </producto>
  <producto>
    <nombre>Producto 2</nombre>
    <descripcion>Descripción del producto 2</descripcion>
    <precio>15.99</precio>
  </producto>
  <producto>
    <nombre>Producto 3</nombre>
    <descripcion>Descripción del producto 3</descripcion>
    <precio>20.99</precio>
  </producto>
</catalogo>

Salida:

<html>
   <head>
      <title>Catálogo de Productos</title>
   </head>
   <body>
      <h1>Catálogo de Productos</h1>
      <div class="producto">
         <h2>Producto 1</h2>
         <p>Descripción del producto 1</p>
         <p>Precio: 10.99</p>
      </div>
      <div class="producto">
         <h2>Producto 2</h2>
         <p>Descripción del producto 2</p>
         <p>Precio: 15.99</p>
      </div>
      <div class="producto">
         <h2>Producto 3</h2>
         <p>Descripción del producto 3</p>
         <p>Precio: 20.99</p>
      </div>
   </body>
</html>

Esperamos que este tutorial te haya resultado útil para crear transformaciones y estilos personalizados para tus documentos XML. Te recordamos que este tutorial se incluye dentro de un paquete de tutoriales en los que exploramos diversos aspectos del lenguaje XML y sus tecnologías asociadas. ¡Continua tu aprendizaje con los tutoriales de DTD o XS D!