Tutorial XSLT, realiza transformaciones sobre XML

08/07/2023

En este tutorial de XSLT (Extensible Stylesheet Language Transformations) veremos como transformar y presentar documentos XML utilizando XSLT. 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 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.

1. Tutorial XSLT: Introducción

XSLT (Transformaciones XSL) es un lenguaje de programación declarativo 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.

Para llevar a cabo una transformación XML utilizando XSLT, se necesitan cuatro elementos principales:

El documento XML: Este es el documento inicial que contiene los datos que se van a transformar. Es la fuente de información sobre la cual se aplicarán las reglas de transformación.
La hoja de estilo XSLT: Este documento contiene el código fuente del programa de transformación. Define las reglas y estructuras de cómo los datos del documento XML deben ser procesados y transformados. La hoja de estilo XSLT especifica qué elementos y atributos del documento XML deben ser seleccionados, cómo deben ser modificados y cómo se debe formatear la salida.
El procesador XSLT: Es el programa de software que ejecuta la transformación definida en la hoja de estilo XSLT sobre el documento XML. El procesador XSLT interpreta las instrucciones del código XSLT y aplica las reglas de transformación al documento XML de entrada. Luego, genera el resultado de la transformación según lo especificado en la hoja de estilo.
El resultado de la ejecución del programa: Es un nuevo documento, que puede ser en formato XML u otro formato según las reglas definidas en la hoja de estilo XSLT. Este documento final representa la salida de la transformación y contiene los datos procesados y/o formateados de acuerdo con las reglas establecidas en la hoja de estilo.

2. Hoja de estilo XSLT

Las hojas de estilo XSLT se construyen sobre estructuras denominadas plantillas (templates). Una plantilla indica 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».

Una hoja de estilo XSLT es un documento XML que contiene al menos las etiquetas siguientes:

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

3. Cómo crear una hoja de estilo XSLT

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.

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

Dentro del elemento raíz xsl:stylesheet se indican 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:

<?xml version="1.0" encoding="UTF-8"?>
<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.

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 cogerá 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" encoding="UTF-8"?>
<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 queramos 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.
Editores de código: Muchos editores de código ofrecen herramientas y extensiones para facilitar el desarrollo y prueba de transformaciones XSLT.
Programas específicos: También existen programas específicos diseñados para crear y ejecutar transformaciones XSLT.

6. Elementos

Existen varios elementos XSLT que se pueden insertar en la plantilla o template para realizar las distintas acciones. En la siguiente tabla se muestran algunos de los elementos más comunes utilizados en XSLT.

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:

<?xml version="1.0" encoding="UTF-8"?>
<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:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Definir la regla de coincidencia para el elemento book -->
  <xsl:template match="book">
    <!-- Utilizar xsl:value-of para mostrar el contenido de la etiqueta title -->
    <xsl:value-of select="title"/>
  </xsl:template>
</xsl:stylesheet>

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:

<?xml version="1.0" encoding="UTF-8"?>
<alumno nombre="Severo Ochoa" edad="20" curso="Informática" />

Archivo XSL:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Definir la regla de coincidencia para el elemento alumno -->
  <xsl:template match="alumno">
    <div>
      <h2>Información del alumno:</h2>
      <!-- Utilizar xsl:value-of para mostrar los valores de los atributos -->
      <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>
</xsl:stylesheet>

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 XML:

<?xml version="1.0" encoding="UTF-8"?>
<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>

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

Salida:

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

En XSLT, xsl:apply-templates y xsl:template trabajan juntos para realizar la transformación del documento XML de entrada en el documento de salida deseado.

xsl:apply-templates: Este elemento se utiliza para indicar al procesador XSLT que seleccione y procese ciertos nodos del documento XML de entrada. La selección de nodos se basa en el patrón de coincidencia (match) definido en las plantillas correspondientes. Cuando se encuentra un nodo que coincide con el patrón de coincidencia especificado en una plantilla, el procesador XSLT aplica esa plantilla al nodo.
xsl:template: Este elemento se utiliza para definir las reglas de transformación que se aplicarán a los nodos seleccionados por xsl:apply-templates. Cada xsl:template especifica qué hacer con un tipo específico de nodo que coincide con el patrón de coincidencia. Cuando se encuentra un nodo que coincide con el patrón de coincidencia de una plantilla, el procesador XSLT ejecuta las instrucciones dentro de esa plantilla para generar parte del resultado de la transformación.

En el ejemplo proporcionado:

La plantilla sin nombre (match="/") se aplica al nodo raíz del documento XML de entrada. Dentro de esta plantilla, se utiliza xsl:apply-templates para seleccionar todos los nodos <ciudad> en el documento XML de entrada y aplicar las plantillas correspondientes.
La segunda plantilla (match="ciudad") se aplica a cada nodo <ciudad> seleccionado por xsl:apply-templates. Dentro de esta plantilla, se utiliza xsl:value-of para extraer y mostrar el contenido del elemento <nombre> de cada nodo <ciudad>. Además, los nodos <ciudad> se ordenan por el valor del elemento <nombre> en orden descendente utilizando xsl:sort.

xsl:apply-templates se utiliza para seleccionar y procesar los nodos del documento XML de entrada, mientras que xsl:template se utiliza para definir cómo se deben procesar los diferentes tipos de nodos seleccionados por xsl:apply-templates. Juntos, estos elementos permiten realizar la transformación deseada del documento XML.

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.

La siguiente tabla muestra ejemplos de expresiones booleanas que se pueden usar en el atributo test del elemento <xsl:if> en XSLT. Las expresiones se presentan junto con ejemplos específicos para cada tipo de expresión.

Expresión	Ejemplo
Igualdad	`<xsl:if test="precio = 100">`
Desigualdad	`<xsl:if test="tipo != 'Libro'">`
Relación	`<xsl:if test="cantidad < 10">`
Lógica	`<xsl:if test="(precio >= 50) and (cantidad < 100)">` `<xsl:if test="(tipo = 'Electrónico') or (tipo = 'Informático')">`
Función	`<xsl:if test="contains(nombre, 'X')">`

Tabla 2: Ejemplos de expresiones booleanas que se pueden usar en el atributo test

1.Ejemplo:

Archivo XML (estudiantes.xml):

<?xml version="1.0" encoding="UTF-8"?>
<clase>
  <estudiante>
    <nombre>Javier García</nombre>
    <calificacion>85</calificacion>
  </estudiante>
  <estudiante>
    <nombre>Marta López</nombre>
    <calificacion>75</calificacion>
  </estudiante>
  <estudiante>
    <nombre>Alejandro Martínez</nombre>
    <calificacion>90</calificacion>
  </estudiante>
  <estudiante>
    <nombre>Isabel González</nombre>
    <calificacion>60</calificacion>
  </estudiante>
</clase>

Archivo XSLT (calificaciones.xslt):

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Definir la regla de coincidencia para el elemento estudiante -->
  <xsl:template match="estudiante">
    <!-- Utilizar xsl:if para condicionalmente mostrar el párrafo si la calificación es >= 80 -->
    <xsl:if test="calificacion &gt;= 80">
      <p>
        <xsl:value-of select="nombre" /> ha aprobado el examen con una calificación de <xsl:value-of select="calificacion" />.
      </p>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

Salida esperada:

<p>
  Javier García ha aprobado el examen con una calificación de 85.
</p>
<p>
  Alejandro Martínez ha aprobado el examen con una calificación de 90.
</p>

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:

Archivo XML (productos.xml):

<?xml version="1.0" encoding="UTF-8"?>
<productos>
  <product>
    <name>Laptop</name>
    <price>800</price>
  </product>
  <product>
    <name>Headphones</name>
    <price>30</price>
  </product>
  <product>
    <name>Smartphone</name>
    <price>120</price>
  </product>
</productos>

Archivo XSLT (ofertas.xslt):

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Definir la regla de coincidencia para el elemento product -->
  <xsl:template match="product">
    <!-- Utilizar xsl:if para condicionalmente mostrar el bloque si el precio es < 50 -->
    <xsl:if test="price &lt; 50">
      <div class="sale">
        <h2>
          <xsl:value-of select="name" />
        </h2>
        <p>
          ¡En oferta por <xsl:value-of select="price" /> euros!
        </p>
      </div>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

Salida esperada:

<div class="sale">
  <h2>Headphones</h2>
  <p>
    ¡En oferta por 30 euros!
  </p>
</div>

En este ejemplo, el producto «Headphones» tiene un precio inferior a 50, por lo que se cumple la condición del <xsl:if> y se genera la salida correspondiente con el precio en euros. Los productos «Laptop» y «Smartphone» no cumplen la condición y, por lo tanto, no generan ninguna salida en la transformación.

3. Ejemplo:

Archivo XML (personas.xml):

<?xml version="1.0" encoding="UTF-8"?>
<personas>
  <person>
    <name>Ana</name>
    <age>25</age>
  </person>
  <person>
    <name>Carlos</name>
    <age>30</age>
  </person>
  <person>
    <name>Marta</name>
    <age>35</age>
  </person>
</personas>

Archivo XSLT (seleccionados.xslt):

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Definir la regla de coincidencia para el elemento person -->
  <xsl:template match="person">
    <!-- Utilizar xsl:if para condicionalmente mostrar el bloque si age es igual a 30 -->
    <xsl:if test="age = 30">
      <div class="selected">
        <h2>
          <xsl:value-of select="name" />
        </h2>
        <p>
          Edad: <xsl:value-of select="age" />
        </p>
      </div>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

Salida esperada:

<div class="selected">
  <h2>Carlos</h2>
  <p>
    Edad: 30
  </p>
</div>

En este ejemplo, solo se generará la salida para la persona con el nombre «Carlos» ya que tiene una edad igual a 30. Las personas con edades diferentes no cumplirán la condición y, por lo tanto, no generarán ninguna salida en la transformación.

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:

<?xml version="1.0" encoding="UTF-8"?>
<libros>
  <libro>
    <autor>John Smith</autor>
  </libro>
  <libro>
    <autor>Jane Doe</autor>
  </libro>
  <libro>
    <autor>Michael Johnson</autor>
  </libro>
</libros>

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

La expresión <xsl:value-of select="." /> en XSLT se utiliza para seleccionar el contenido del nodo actual y copiarlo en el resultado de la transformación.

El punto (.) se refiere al contexto actual dentro del bucle <xsl:for-each>, que en este caso son los nodos <autor>. Por lo tanto, <xsl:value-of select="." /> selecciona y muestra el contenido de cada nodo <autor> en el resultado de la transformación.

Alternativamente, podríamos utilizar <xsl:value-of select="text()" /> para lograr el mismo resultado. La expresión text() selecciona el contenido de texto del nodo actual, que en este caso sería el texto dentro de los nodos <autor>. Entonces, <xsl:value-of select="text()" /> también mostraría el contenido de cada nodo <autor> en el resultado de la transformación.

7. Tutorial XSLT: Ejercicios resueltos

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.

Ver ejercicios XSLT resueltos y tipo examen

Esperamos que este tutorial XSLT 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 estudiamos diversos aspectos del lenguaje XML y sus tecnologías asociadas. ¡Continua tu aprendizaje con los tutoriales de DTD o XS D!

Tutorial XSLT, realiza transformaciones sobre XML

¡Invítanos a un café!

Servicios

Suscríbete a la newsletter