Ud13 XSL PDF

I.E.S.
Trassierra
Departamento de Informática
Desarrollo de Aplicaciones Web
Módulo Profesional de Lenguajes de Marcas y

Sistemas de Información
Unidad 13 - EXtensible Stylesheet Language

Introducción................................................................................................................................... 2
XPath .............................................................................................................................................. 2
¿Qué es XPath ............................................................................................................................ 2
Árbol del documento................................................................................................................. 2
Tipos de nodos .......................................................................................................................... 3
Sintaxis de las expresiones XPath ............................................................................................. 5
XSLT - Transformaciones XSL ........................................................................................................ 13
Hojas de estilo XSLT ................................................................................................................. 13
Enlazar documentos XML con hojas de estilo XSL ................................................................... 14
Plantillas XSLT........................................................................................................................... 18
Plantillas vacías o inexistentes ............................................................................................. 18
Instrucción <xsl:value-of> .................................................................................................... 19
Instrucción <xsl:apply-templates ........................................................................................ 20
Elemento <xsl:for-each> ...................................................................................................... 22
Elemento <xsl:sort> ............................................................................................................. 22
Elemento <xsl:if test> ..........................................................................................................23
Elemento <xsl:choose> ........................................................................................................23
Elemento <xsl:text> ............................................................................................................ 25
Elemento <xsl:attibute>...................................................................................................... 25
Elemento <xsl:variable> ...................................................................................................... 26
Elemento <xsl:param> .........................................................................................................27
Elemento <xsl:copy-of> ...................................................................................................... 28
Elemento <xsl:copy> ........................................................................................................... 29
Elemento <xsl:call-template> ............................................................................................. 30
Contar marcas ...................................................................................................................... 31
Filtrando la salida ................................................................................................................. 31
CSS + XML sobre ficheros XML .....................................................................................................32
XSL 1/34
I.E.S. Trassierra
Introducción
Aunque las hojas de estilo CSS se pueden aplicar a los documentos XML, las hojas de estilo tienen
muchas limitaciones ya que se crearon para complementar al HTML, es decir, para ver páginas web en
pantallas de ordenador. De la misma manera que el XML es una generalización del HTML, el W3C creó
una generalización de las hojas de estilo CSS a la que se denominó XSL (eXtensible Stylesheet Languaje),
es decir, Lenguaje de hojas de estilo extensible. Está basado en la combinación de tres tecnologías:
 XPath. Lenguaje de navegación para referirse a partes de un documento XML.

 XSLT (XSL Transformation). Lenguaje de transformación de documentos XML.
 XSL-FO (XSL Formatting Objects). Lenguaje para especificar el formato de un documento XML y
posteriormente convertirlo a PDF o PostScript.
XPath: XML Path language

Qué es XPath
XPath es un lenguaje que permite seleccionar nodos de un documento XML y calcular valores a partir de
su contenido. Existen tres versiones de XPath aprobadas por el W3C, aunque la versión más utilizada
sigue siendo la versión 1:
 noviembre de 1999: XML Path Language 1.0
 enero de 2007: XML Path Language 2.0
 diciembre de 2010: XML Path Language 2.0 (2º edición)
 abril de 2014: XML Path Language 3.0
Árbol del documento

XPath considera un documento XML como un árbol de nodos. En Informática, un árbol es una
estructura de datos que equivale a un árbol matemático. En Matemáticas un árbol es un caso particular
de grafo. Los siguientes términos definidos en teoría de grafos se utilizan también en Informática y en
XPath:
 Un grafo es un conjunto de objetos llamados nodos o vértices unidos por enlaces llamados arcos o
aristas. Un grafo dirigido es un grafo en el que los arcos tienen dirección.
 Cuando dos nodos están unidos por un arco con dirección, el nodo padre es el nodo del que parte el
arco y el nodo hijo es el nodo al que llega el arco.
XML 2/34
I.E.S. Trassierra
 Un árbol es un grafo en el que cualquier pareja de vértices están conectada por un único camino (es
decir, que no hay ciclos). Un árbol dirigido es un árbol en el que las aristas tienen dirección y todos
los nodos menos uno tienen un único padre.
 El nodo raíz de un árbol dirigido es el único nodo sin padre. Los nodos hermanos son los nodos que
tienen el mismo padre.
 Los nodos descendientes de un nodo son todos los nodos a los que se llega desde el nodo: los hijos,
los hijos de los hijos, etc. Los nodos ascendientes de un nodo son todos los nodos de los que un nodo
es descendiente: el padre, el padre del padre, etc.
Tipos de nodos
Un documento XML puede representarse como un árbol dirigido, considerando por ejemplo los
elementos como nodos y que un elemento es padre de los elementos que contiene. Pero en XPath no
sólo los elementos son nodos, en realidad hay siete tipos de nodos:
 Raíz
 Elemento
 Atributo
 Texto
 Comentario
 Instrucción de procesamiento
XML 3/34
I.E.S. Trassierra
 Espacio de nombres
Nota: La declaración DOCTYPE no se considera como nodo.
Por ejemplo, el documento primero.xml siguiente:
<?xml version="1.0" encoding="UTF-8"?>

<biblioteca>
<libro>
<titulo>La vida está en otra parte</titulo>
<autor>Milan Kundera</autor>
<fechaPublicacion año="1973"/>
</libro>
<libro>
<titulo>Pantaleón y las visitadoras</titulo>
<autor fechaNacimiento="28/03/1936">Mario Vargas Llosa</autor>
</libro>
<libro>
<titulo>Conversación en la catedral</titulo>
</libro>
</biblioteca>
se puede representar mediante el siguiente grafo:
Los nodos atributos y de texto no son como los nodos elemento. Por ejemplo, los nodos atributo y de
texto no pueden tener descendientes. En realidad el nodo atributo ni siquiera se considera como hijo,
sino como una etiqueta adosada al elemento. El texto contenido por una etiqueta sí que se considera
XML 4/34
I.E.S. Trassierra
hijo del elemento, aunque las expresiones XPath suelen trabajar con nodos elemento y para referirse a
los atributos o al texto se utilizan notaciones especiales.
Sintaxis de las expresiones XPath

Una expresión XPath es una cadena de texto que representa un recorrido en el árbol del documento.
Las expresiones más simples se parecen a las rutas de los archivos en el explorador de Windows o en la
shell de GNU/Linux.
Evaluar una expresión XPath es buscar si hay nodos en el documento que se ajustan al recorrido
definido en la expresión. El resultado de la evaluación son todos los nodos que se ajustan a la expresión.
Para poder evaluar una expresión XPath, el documento debe estar bien formado.
Las expresiones XPath se pueden escribir de dos formas distintas:

 sintaxis abreviada: más compacta y fácil de leer, que se explica a continuación.
 sintaxis completa: más larga pero con más opciones disponibles.
Las expresiones XPath se pueden dividir en pasos de búsqueda. Cada paso de búsqueda se puede a su
vez dividir en tres partes:
 eje: selecciona nodos elemento o atributo basándose en sus nombres.
 predicado: restringe la selección del eje a que los nodos cumplan ciertas condiciones.
 selección de nodos: de los nodos seleccionados por el eje y predicado, selecciona los elementos,
el texto que contienen o ambos.
Sintaxis abreviada
Veamos unos ejemplos de expresiones XPath de sintaxis abreviada y el resultado de su evaluación
basados en el ejemplo de la página anterior:
Eje (en inglés, axis)

El eje nos permite seleccionar un subconjunto de nodos del documento y corresponde a recorridos en el
árbol del documento. Los nodos elemento se indican mediante el nombre del elemento. Los nodos
atributo se indican mediante @ y el nombre del atributo.
 /: si está al principio de la expresión, indica el nodo raíz, si no, indica "hijo". Debe ir seguida del
nombre de un elemento.
XML 5/34
I.E.S. Trassierra
Nota: En XPath 1.0 no se puede seleccionar únicamente el valor del atributo, sino que se obtienen
respuestas del tipo nombreDelAtributo=ValorDelAtributo
 //: indica "descendiente" (hijos, hijos de hijos, etc.). Sirve para seleccionar, directamente un
elemento sin tener que especificar la ruta completa.
 /..: indica el elemento padre.
Ejemplo 1: Selecciona todos los padres de la ruta que tengan como atributo fechaNacimiento, es decir, todos los
autores.
Ejemplo 2: Selecciona todos los padres de los padres de la ruta que tengan como atributo fechaNacimiento, es
decir todos los libros con atributo fechaNacimiento.
XML 6/34
I.E.S. Trassierra
 |: permite indicar varios recorridos.
Predicado (en inglés, predicate)

El predicado se escribe entre corchetes, a continuación del eje. Si el eje ha seleccionado unos nodos, el
predicado permite restringir esa selección a los que cumplan determinadas condiciones.
 [@atributo]: selecciona los elementos que tienen el atributo.
 [número]: si hay varios resultados selecciona uno de ellos por número de orden; last() selecciona el
último de ellos
 [condicion]: selecciona los nodos que cumplen la condición.

Los predicados permiten definir condiciones sobre los valores de los atributos. En las condiciones
se pueden utilizar los operadores siguientes:
 operadores lógicos: and, or, not()
 operadores aritméticos: +, -, *, div, mod
 operadores de comparación: =, !=, <, >, <=, >=
XML 7/34
I.E.S. Trassierra
Las comparaciones se pueden hacer entre valores de nodos y atributos o con cadenas de texto o
numéricas. En el caso de las cadenas de texto deben estar rodeadas por comillas simples o dobles.
En el caso de las cadenas numéricas, las comillas son optativas.
La condición puede utilizar el valor de un atributo (utilizando @) o el texto que contiene el

elemento.
En los ejemplos siguientes se obtienen respectivamente los elementos <fechaPublicacion> cuyo

atributo año es posterior/mayor a 1970 y los elementos <libro> cuyo subelemento <autor> tiene
como contenido "Mario Vargas LLosa":
Se pueden escribir varios predicados seguidos, cada uno de los cuales restringe los resultados del
anterior, como si estuvieran encadenados por la operación lógica and. En el ejemplo siguiente se
seleccionan los libros escritos por Mario Vargas Llosa y publicados en 1973:
Un predicado puede contener condiciones compuestas. En los ejemplos siguientes se seleccionan,

respectivamente , los libros escritos por Mario Vargas Llosa y publicados en 1973 (primer ejemplo) y
los libros escritos por Mario Vargas Llosa o publicados en 1973 (segundo ejemplo):
XML 8/34
I.E.S. Trassierra
Selección de nodos (en inglés, node test)

La selección de nodos se escribe a continuación del eje y el predicado. Si el eje y el predicado han
seleccionado unos nodos, la selección de nodos indica con qué parte de esos nodos nos quedamos.
 /node(): selecciona todos los hijos (elementos o texto) del nodo.
//node(): selecciona todos los descendientes (elementos o texto) del nodo.
XML 9/34
I.E.S. Trassierra
 /text(): selecciona únicamente el texto contenido en el nodo.

//text(): selecciona únicamente el texto contenido en el nodo y todos sus descendientes.
 /*: selecciona todos los hijos (sólo elementos) del nodo.

//*: selecciona todos los descendientes (sólo elementos) del nodo.
XML 10/34
I.E.S. Trassierra
 /@*: selecciona todos los atributos del nodo.

//@*: selecciona todos los atributos de los descendientes del nodo.
Operadores XPath
XML 11/34
I.E.S. Trassierra
Las expresiones XPath pueden incluir operadores o funciones, y devuelven un conjunto de nodos, una
cadena de caracteres (string), un valor booleano (verdadero o falso, V o F), o un número. Los siguientes
son operadores que pueden usarse en expresiones XPath:
Funciones XPath
XPath dispone de más de un centenar de funciones predefinidas (que comparten XPath 2.0, XQuery 1.0
y XSLT 2.0) de tipo muy diverso:
Funciones de nodo
Funciones de cadena
XML 12/34
I.E.S. Trassierra
Funciones numéricas
Funciones lógicas
Dentro de un XSL, la forma de utilizar el lenguaje XPath sería siguiendo la siguiente sintaxis:
Expresión Descripción
<xsl:value-of select=”biblioteca”/> Selecciona todos los nodos biblioteca. Previamente en el
template tendremos un match de un nodo del cual colgaría
biblioteca.
<xsl:value-of select=”/biblioteca”/> Especificamos la ruta desde el elemento raíz. En este caso
biblioteca sería la raíz del documento.
<xsl:value-of select=”//libro”/> Selecciona todos los elementos libro que existan en
cualquier parte del documento.
<xsl:value-of select=”.”/> Selecciona el nodo actual.
<xsl:value-of select=”..”/> Nodo padre del nodo actual
<xsl:value-of select=”@lang”/> Selecciona el atributo lang del elemento actual.
<xsl:value-of select=”nodo/@*”/> Selección de todos los atributos de un nodo concreto.
<xsl:value-of select=”//@lang”/> Selecciona todos los atributos que son llamados lang.
XML 13/34
I.E.S. Trassierra
Podemos hacer referencia a cualquier nodo o cualquier atributo usando respectivamente * o @*. Por
ejemplo:
/biblioteca/* selecciona todos los nodos hijos de biblioteca.
/title[@*] selecciona los nodos título que tienes algún atributo.
XSLT: Transformaciones XSL

XSLT (Transformaciones XSL) es un lenguaje de programación declarativo que permite generar
documentos a partir de documentos XML, como ilustra la imagen siguiente:
 El documento XML es el documento inicial a partir del cual se va a generar el resultado.

 La hoja de estilo XSLT es el documento que contiene el código fuente del programa, es decir, las
reglas de transformación que se van a aplicar al documento inicial.
 El procesador XSLT es el programa de ordenador que aplica al documento inicial las reglas de
transformación incluidas en la hoja de estilo XSLT y genera el documento final.
 El resultado de la ejecución del programa es un nuevo documento (que puede ser un
documento XML o no).
A un documento XML se le pueden aplicar distintas hojas de estilo XSLT para obtener distintos
resultados y una misma hoja de estilo XSLT se puede aplicar a distintos documentos XML.
Hojas de estilo XSLT

XSLT es un lenguaje declarativo. Por ello, las hojas de estilo XSLT no se escriben como una secuencia de
instrucciones, sino como una colección de plantillas (template rules). Cada plantilla establece cómo se
transforma un determinado elemento (definido mediante expresiones XPath). La transformación del
documento se realiza de la siguiente manera:
 El procesador analiza el documento y construye el árbol del documento.
 El procesador va recorriendo todos los nodos desde el nodo raíz, aplicando a cada nodo una
plantilla, sustituyendo el nodo por el resultado.
 Cuando el procesador ha recorrido todos los nodos, se ha terminado la transformación.
Una hoja de estilo XSLT es un documento XML que contiene al menos las etiquetas siguientes:
Estas etiquetas son:

 la declaración xml <?xml>, propia de cualquier documento XML.
 la instrucción <xsl:stylesheet> es la etiqueta raíz de la hoja de estilo, sus atributos indican la
versión y el espacio de nombres correspondiente.
XML 14/34
I.E.S. Trassierra
Dentro de la instrucción <xsl:stylesheet> se pueden encontrar los llamados elementos de alto nivel y las
plantillas, como en el ejemplo siguiente:
Estas etiquetas son

 el elemento de alto nivel <xsl:output> indica el tipo de salida producida.
 la instrucción <xsl:template> es una plantilla.
o El atributo match. El valor de su atributo es una expresión en XPath, por ejemplo
match=”/”, definiría la navegación a partir de la raíz del documento.
o El contenido de la instrucción define la transformación a aplicar y dará como resultado
elementos HTML que serán visualizados por el navegador al realizar la transformación.
Cuando se aplica una plantilla a un nodo, el nodo y todos sus descendientes se sustituyen por el
resultado de la aplicación de la plantilla, lo que nos haría perder a los descendientes. Si antes de aplicar
la plantilla a un nodo se quiere aplicar a los descendientes las plantillas que les correspondan, hay que
utilizar la instrucción <xsl:apply-templates />, como en el ejemplo siguiente:
Enlazar documentos XML con hojas de estilo XSLT

Se puede asociar de forma permanente una hoja de estilo XSLT a un documento XML mediante la
instrucción de procesamiento <?xml-stylesheet ?>. Esta instrucción de procesamiento va al principio del
documento, después de la declaración XML.
Cuando se visualiza en un navegador web un documento XML enlazado con una hoja de estilo XSLT, los
navegadores muestran el resultado de la transformación, aunque si se muestra el código fuente de la
página, los navegadores muestran el documento XML original.
Nota: Google Chrome no muestra los documentos XML que enlazan a hojas de estilo XSLT abiertos
como archivos locales (file://...). Firefox e Internet Explorer sí lo hacen.
XML 15/34
I.E.S. Trassierra
Para empezar, vamos a tratar de presentar una hoja XML de lo más simple (tienda.xml):
<?xml version="1.0" encoding='ISO-8859-1'?>

<?xml-stylesheet href="tienda-html.xsl" type="text/xsl"?>
<tienda>
<nombre>La tiendecilla</nombre>
<telefono>953 87 12 23</telefono>
</tienda>
Para convertirlo en HTML, usaremos la siguiente hoja de estilo (tienda-html.xsl):

Tal como está, se puede cargar directamente con Firefox, que mostrará algo similar a la imagen.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match='/'>
<html>
<head>
<title>Generado con tienda-html.xsl</title>
</head>
<body>
<h1><xsl:apply-templates /></h1>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Explicación del código

En la primera línea del código del documento XML se asocia la hoja de estilo XSLT (tienda-html.xsl) al
documento.
El XML original, es simplemente XML bien formado, no usa un DTD ni lo necesita: basta con que haya
una etiqueta raíz (tienda, en nuestro caso). Diferentes documentos XML podrían ser procesados con la
misma hoja de estilo, y darían diferente resultado. Debemos tener en cuenta que muchos documentos
XML pueden tener la misma hoja XSL y de esa forma mantener una apariencia común.
Para empezar, se incluyen una serie de instrucciones: no son instrucciones en sí, sino que modifican el
aspecto de la salida. La primera declara el documento XML y el tipo de codificación (que podría ser ISO-
8859-1 en vez de UTF-8 si quisiéramos incluir acentos y demás caracteres idiosincráticos) y la segunda es
la etiqueta raíz de la hoja de estilo (cerrada en la última línea; recordemos que una hoja de estilo XSL es
también un documento XML y por tanto tiene que seguir todas sus convenciones), que declara la
versión de XSLT que se está usando y el espacio de nombres (namespace) que vamos a usar. En este
caso, usamos como prefijo xsl, pero cambiando la instrucción anterior podríamos usar otro cualquiera.
Ese esqueleto está organizado en "templates", que son partes de la hoja que se "disparan" cuando
encuentran una etiqueta que corresponda a lo que hay en su atributo match. El único template que
corresponde a la etiqueta raíz, genera un esqueleto de página HTML. La "orden" <xsl:apply-templates />
cede el control a los otros templates, es decir, trata de aplicar todos los demás templates que haya en el
documento (es decir, entre las etiquetas h1). La orden <xsl:apply-templates /> podría haberse sustituido,
en este caso, por <xsl:value-of select='tienda' /> y habría tenido exactamente el mismo efecto, es decir,
incluir el contenido de la etiqueta tienda (y todas las que descienden de ella).
XML 16/34
I.E.S. Trassierra
Ahora vamos a tratar de procesar documentos XML que describen diferentes artículos de una tienda
virtual formada por diferentes productos, que tienen una serie de características: código de producto,
tipo de artículo, sección. Una tienda virtual se describiría en un fichero como el siguiente (tienda1.xml):
<?xml version="1.0" encoding='ISO-8859-1'?>

<?xml-stylesheet href="tienda1-html.xsl" type="text/xsl"?>
<tienda>
<nombre>La tiendecilla</nombre>
<telefono>953 87 12 23</telefono>
<producto>
<codigo>92</codigo>
<cantidad>10</cantidad>
<articulo>Radio-Casette</articulo>
</producto>
<producto>
<codigo>103</codigo>
<articulo>Reloj Cocina</articulo>
</producto>
<producto>
<codigo>1312</codigo>
<articulo>Sofá</articulo>
</producto>
</tienda>
Este se transforma con la siguiente hoja XSLT (tienda1-html.xsl):

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match='/'>
<html>
<xsl:apply-templates />
</html>
</xsl:template>
<xsl:template match='tienda'>
<head>
<title><xsl:value-of select='nombre' />(Generado por tienda1-html.xsl)</title>
</head>
<body>
<h1><xsl:value-of select='nombre' /></h1>
<h2>Teléfono:<xsl:value-of select='telefono' /></h2>
<h2>Nuestros mejores productos</h2>
<table>
<tr>
<th>Código</th>
<th>Existencias</th>
<th>Artículo</th>
</tr><xsl:apply-templates select='producto' />
</table>
</body>
</xsl:template>
<xsl:template match='producto'>
<tr><xsl:apply-templates /></tr>
</xsl:template>
<xsl:template match='codigo|cantidad|articulo'>
<td><xsl:apply-templates /></td> <!- -o xsl:value-of select=”.”- ->
</xsl:template>
</xsl:stylesheet>
XML 17/34
I.E.S. Trassierra
Esta hoja se compone de cuatro templates diferentes, mientras que la anterior tenía solamente uno.
Cada template trata elementos de diferente profundidad dentro del árbol del documento XML:
 El primer template trataría la raíz.
 El segundo las ramas que descienden de él.
 El tercer y cuarto ramas progresivamente más bajas.
Por eso el primer template se aplicará a todos los elementos que “cuelgan” de la raíz del codumenteo
XML y cede el control al siguiente template, que trata la primera etiqueta, tienda, tal como aparece en el
atributo match. En este template se incluyen dentro del patrón en HTML el nombre y al telefono,
usando xsl:value-of, que simplemente incluye el contenido del elemento correspondiente.
También se crea el esqueleto de una tabla en HTML, con su cabecera, y cede control al siguiente
template, que se encargará de cada uno de los productos; para que se procesen sólo las etiquetas de
este tipo que desciendan de tienda, y no las otras (nombre, telefono), que ya están incluidas en la salida,
se usa xsl:apply-templates select='producto' se aplicarán sólo los templates que correspondan a este
elemento.
Ese template crea el esqueleto de una fila, cediendo el control a los templates que traten con los
descendientes. Hay un sólo template que lo hace que, en vez de procesar un sólo tipo de elemento,
procesa 3, y para ello usamos | para indicar que puede procesar cualquiera de ellos, incluyéndolos
dentro de un demarcador de celda de tabla en HTML.
El orden en el que se incluyen los elementos en la salida es el mismo en el que se encuentran en la

entrada, es lo que se denomina orden de documento. Este orden se puede alterar usando etiquetas
value-of adecuadamente y usando otros métodos.
El resultado al verlo en el navegador Web será:
Como vemos, hay dos dormas de aplicar una plantilla:

 De forma completa para todos los mach: <xsl:apply-templates />
 De forma particular para un match concreto: <xsl:apply-templates select='producto' />
XML 18/34
I.E.S. Trassierra
Ejercicio1: Partiendo del siguiente documento XML (ejercicio1.xml), queremos obtener la siguiente
salida en un navegador Web. Crea un fichero llamado ejercicio1.xsl que le sirva de plantilla.

<?xml-stylesheet href="ejercicio1.xsl" type="text/xsl"?>
<biblioteca>
<libro>
<titulo>La vida está en otra parte</titulo>
<autor>Milan Kundera</autor>
</libro>
<libro>
<titulo>Pantaleón y las visitadoras</titulo>
</libro>
<libro>
<titulo>Conversación en la catedral</titulo>
</libro>
</biblioteca>
Plantillas XSLT
Vamos a ver ejemplos de plantillas trabajando sobre el documento inicial primero.xml. Es el mismo que
el del ejercicio anterior.
Plantillas vacías o no existentes

 Si no hay plantillas, el procesador simplemente extrae el texto contenido por los nodos. En el
ejemplo siguiente, el resultado incluye el contenido de los nodos <título> y <autor> puesto que
no hay ninguna plantilla.
 Si hay una plantilla vacía, el procesador sustituye el nodo y todos sus subelementos por nada y
no extrae el texto contenido por ese nodo o sus subelementos. En el ejemplo siguiente, el
resultado incluye el contenido de los nodos <titulo>, ya que no hay regla para ellos, pero los de
<autor> se pierden porque la plantilla es vacía.
XML 19/34
I.E.S. Trassierra
 En el caso más extremo, si la plantilla vacía se aplica al nodo raíz, el procesador sustituye el nodo
raíz y todos sus descendientes por nada y no extrae el texto contenido en ningún subelemento.
En el ejemplo siguiente, el resultado no incluye nada porque la única plantilla ha sustituido el
nodo raíz y todos sus subelementos.
La instrucción <xsl:value-of>
Se usa para seleccionar el valor de un elemento XML y añadirlo al documento resultado de la
transformación. El elemento se selecciona por medio del atributo obligatorio select, que toma como
valor una expresión de XPath. En el ejemplo siguiente, los títulos de los libros se han perdido, porque el
nodo <libro> (y sus subnodos <autor> y <titulo>) se sustituye por el contenido del nodo <autor>.
En el ejemplo siguiente, se obtienen el titulo y el autor de los libros, pero uno a continuación de otro.
En el ejemplo siguiente, los autores se obtienen gracias a la regla que extrae el contenido del nodo (el
carácter punto "." hace referencia al propio elemento) y los títulos se obtienen porque al no haber
reglas para ese nodo se extrae el contenido.
XML 20/34
I.E.S. Trassierra
En el ejemplo siguiente, las fechas de publicación se obtienen gracias a la regla que extraen el valor del
atributo y los títulos y autores se obtienen ya que al no haber reglas para el nodo se extrae el contenido.
Aplicar reglas a subnodos: la instrucción <xsl:apply-templates>

La instrucción <xsl:apply-templates> aplica una plantilla al elemento actual o a sus nodos hijos.
Mediante el atributo select se añaden los nodos seleccionados. También puede usarse para especificar
el orden en que se procesarán los nodos hijos. Sirve para llamar a otras plantillas o templates dentro de
un template. Se aplica a los nodos a partir del nodo actual.
La sintaxis de este elemento es:
<xsl:apply-template
select = Expresion
mode = Nombre calificado >
</xsl:apply-template>
En el ejemplo siguiente, se genera la etiqueta <html> además de unos párrafos con los nombres de los
autores. La primera regla sustituye el elemento raíz (y todos sus subelementos) por las etiquetas <html>
y <h1>, pero además aplica a los subelementos las reglas que les son aplicables. En este caso, sólo hay
una regla para los elementos <libro> que generan los párrafos.
 Se utiliza para procesar nodos seleccionados mediante una expresión XPath, en lugar de
procesar a todos los hijos.
 Permite que un elemento especificado por sus Nombre calificado, se procese varias veces,
produciendo cada vez un resultado diferente.
XML 21/34
I.E.S. Trassierra
Veamos otro ejemplo: estudiantes2.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>
<body>
<h2>Estudiantes</h2>
<xsl:apply-templates select = "clases/estudiante" />
</body>
</html>
</xsl:template>
<xsl:template match = "clases/estudiante">

<xsl:apply-templates select = "@nunmatri" />
<xsl:apply-templates select = "nombre" />
<xsl:apply-templates select = "apellido" />
<xsl:apply-templates select = "nick" />
<xsl:apply-templates select = "calificacion" />
<br />
</xsl:template>
<xsl:template match = "@nunmatri">

<span style = "font-size = 22px;">
<xsl:value-of select = "." />
</span>
<br />
</xsl:template>
<xsl:template match = "nombre">

Nombre:<span style = "color:blue;">
</span>
<br />
</xsl:template>
<xsl:template match = "apellido">

Apellidos:<span style = "color:green;">
</span>
<br />
</xsl:template>
<xsl:template match = "nick">

Nick:<span style = "color:red;">
</span>
<br />
</xsl:template>
<xsl:template match = "calificacion">

Calificación:<span style = "color:gray;">
</span>
<br />
</xsl:template>
</xsl:stylesheet>
XML 22/34
I.E.S. Trassierra
La salida que obtendremos será algo como esto:
El elemento <xsl:for-each>
Se utiliza para procesar de forma iterativa nodos del documento XML. El valor del atributo requerido
select contiene una localización XPath. Ejemplo: supongamos el documento ciudades.xml
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>

<?xml-stylesheet type="text/xsl" href="ciudades2.xsl"?> <xsl:stylesheet version="1.0"
<ciudades> xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<ciudad> <xsl:template match="ciudades">
<nombre>Madrid</nombre> <html>
<habitantes>3500000</habitantes> <head>
</ciudad> <title>Ejemplo de XSLT</title>
<ciudad> </head>
<nombre>Málaga</nombre> <body>
<habitantes>800000</habitantes> <h1>Ciudades:</h1>
</ciudad> <xsl:for-each select="ciudad/nombre"> 
<ciudad> <h3><xsl:value-of select=".">
<nombre>Toledo</nombre> </xsl:value-of>
<habitantes>50000</habitantes> </h3>
</ciudad> </xsl:for-each>
</ciudades> </body>
</html>
ciudades.xsl </xsl:template>
</xsl:stylesheet>
El elemento <xsl:sort>
Usado dentro de un elemento <xsl:for-each>, permite ordenar los elementos del documento fuente
XML atendiendo a un determinado criterio. Acepta dos atributos:
 select: toma como valor el nombre del elemento a utilizar como criterio de ordenación.
 order: indica si se debe utilizar un orden ascendente o descendente.
Ejemplo: Modificar el bucle for-each anterior por el siguiente y comprobar la salida.
<xsl:for-each select="ciudad/nombre">
<xsl:sort select='.' data-type='text'/>
<h3><xsl:value-of select=".">
</xsl:value-of>
</h3>
</xsl:for-each>
XML 23/34
I.E.S. Trassierra
Añadir al fichero XML las siguientes ciudades, al final del mismo:
<ciudad>
<nombre>Córdoba</nombre>
<habitantes>250000</habitantes>
</ciudad>
<ciudad>
<nombre>Granada</nombre>
<habitantes>275000</habitantes>
</ciudad>
El elemento <xsl:if test>

Contiene una plantilla que se aplicará solo si se cumple una determinada condición, que será una
expresión XPath incluida dentro del atributo obligatorio test.
Ejemplo: Modifica el bucle for-each anterior por el siguiente y comprueba la salida.
<xsl:for-each select="ciudad">
<xsl:sort select='.' data-type='text'/>
<xsl:if test='habitantes > 300000'>
<h3><xsl:value-of select="nombre">
</xsl:value-of>
</h3>
</xsl:if>
</xsl:for-each>
El elemento <xsl:choose> (<xsl:when> y <xsl:otherwise>)

Permite expresar tests condicionales múltiples. Puede incluir varios elementos <xsl:when>
(equivalentes a un <xsl:if>, con su atributo obligatorio test), cada uno de los cuales establece una
determinada condición y contiene una plantilla, y un único elemento <xsl:otherwise> (sin dicho
atributo), cuya plantilla se aplicará si no se cumple ninguna de las condiciones expresadas en los
anteriores.
Para ilustrar este elemento comprobemos el siguiente ejercicio: En él se crea una tabla de <estudiantes>
elemento con su atributo nunmatri y su hijo <nombre>, <apellidos>, <nick> y <calificacion> iterando
sobre cada estudiante. Comprueba e imprime los detalles del grado.
estudiantes.xml
<?xml version = "1.0"?>
<?xml-stylesheet type = "text/xsl" href = "estudiantesX.xsl"?>
<clases>
<estudiante nunmatri = "393">
<nombre>Alejandro</nombre>
<apellido>López</apellido>
<nick>alopez</nick>
<calificacion>85</calificacion>
</estudiante>
<nombre>Vanesa</nombre>
<apellido>García</apellido>
<nick>vgarcia</nick>
</estudiante>
XML 24/34
I.E.S. Trassierra
<nombre>Javier</nombre>
<apellido>Sánchez</apellido>
<nick>jsanchez</nick>
</estudiante>
</clases>
estudiantes1.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>
<body>
<h2>Estudiantes</h2>
<table border = "1">
<tr bgcolor = "#9acd32">
<th>No Matrícula</th>
<th>Nombre</th>
<th>Apellido</th>
<th>Nick</th>
<th>Calificación</th>
<th>Grado</th>
</tr>
<xsl:for-each select = "clases/estudiante">
<tr>
<td><xsl:value-of select = "@nunmatri"/></td>
<td><xsl:value-of select = "nombre"/></td>
<td><xsl:value-of select = "apellido"/></td>
<td><xsl:value-of select = "nick"/></td>
<td><xsl:value-of select = "calificacion"/></td>
<td>
<xsl:choose>
<xsl:when test = "calificacion > 90">Alto</xsl:when>
<xsl:when test = "calificacion > 85">Medio</xsl:when>
<xsl:otherwise>Bajo</xsl:otherwise>
</xsl:choose>
</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
La salida obtenida será algo como esto:
XML 25/34
I.E.S. Trassierra
Elemento <xsl:text>
El elemento <xsl texto> se utiliza para escribir texto literal de la salida. Este elemento puede contener
texto, las referencias a entidades, así como #PCDATA.
<xsl:text
disable-output-escaping="yes|no">

</xsl:text>
Ejemplo
Partiendo del archivo cdcatalogo.xml (ejemplos de la plataforma moodle), visualizar cada título del CD.
Si no es el último o penúltimo CD, después de cada título insertar el carácter ",". Si es el penúltimo CD, a
continuación, después del título añadir ", y". Si es el último CD, a continuación, añadir el carácter "!".

<xsl:template match="/">
<html>
<body>
<h2>Mi Colección de CD</h2>
<p>Títulos: <BR/>
<xsl:for-each select="catalogo/cd">
<xsl:value-of select="titulo"/>
<xsl:if test="position() < last()-1">
<xsl:text>, </xsl:text>
</xsl:if>
<xsl:if test="position()=last()-1">
<xsl:text>, y </xsl:text>
</xsl:if>
<xsl:if test="position()=last()">
<xsl:text>!</xsl:text>
</xsl:if>
<BR/>
</xsl:for-each>
</p>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Elemento <xsl:attribute>
La instrucción <xsl:attribute> permite generar un atributo y su valor. Se utiliza cuando el valor del
atributo se obtiene a su vez de algún nodo.
Ejemplo
Añadámosle a nuestro archivo primero.xml las siguientes líneas:
<licencia>
<imagen>Captura.JPG</imagen>
</licencia>
Vamos a crear un archivo llamado ejemplo.xsl donde carguemos una imagen en el navegador usando atributos.
Utiliza como nombre de imagen el que quieras.
XML 26/34
I.E.S. Trassierra

<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<html>
</html>
</xsl:template>
<xsl:template match="licencia">
<p><img>
<xsl:attribute name="src">
<xsl:value-of select="imagen" />
</xsl:attribute>
</img>
</p>
</xsl:template>
</xsl:stylesheet>
Elemento <xsl:variable>
El elemento <xsl:variable> se utiliza para declarar una variable. Las variables nos permiten realizar
operaciones con los datos del documento XML para luego mostrar el resultado en el documento
“resultado”. Es importante señalar que cuando se le asigna un valor a una variable, éste ya no se puede
cambiar . Para declarar una variable, se utilizará la sintáxis:
<xsl:variable name = QName select = Expression </xsl:variable>
Ejemplo
Partimos del archivo pedido.xml (ejemplos de plataforma moodle) y queremos hacer uso de un
elemento variable que me muestre el total de un pedido acumulado.

<xsl:variable name="totalPrecio" select="sum(//total)" />
<html>
<head><title>Pedido</title></head>
<body>
</body></html>
</xsl:template>
<xsl:template match="cliente">
<h2><xsl:value-of select="nombre"/></h2>
<h2><xsl:value-of select="domicilio"/></h2>
<h2><xsl:value-of select="localidad"/></h2>
</xsl:template>
<xsl:template match="detalle">
<table width="25%">
<tr>
<th>Material</th>
<th>Unidades</th>
<th>Precio</th>
<th>Total Pts.</th>
</tr>
XML 27/34
I.E.S. Trassierra
<xsl:for-each select="item">
<tr>
<td><xsl:value-of select="material" /></td>
<td><xsl:value-of select="unidades" /></td>
<td><xsl:value-of select="precio" /></td>
<td><xsl:value-of select="total" /></td>
</tr>
</xsl:for-each>
</table>
<h4>Total a pagar: <xsl:value-of select="$totalPrecio" /></h4>
</xsl:template>
</xsl:stylesheet>
¿Qué crees que habría pasado si no hubiéramos definido una plantilla para el elemento <cliente>?
Elemento <xsl:param>
El elemento <xsl:param> permite generar contenido diferente dependiendo de las entradas mediante el
paso de parámetros a las hojas de estilos. A la vez, teniendo en cuenta las entradas, habrá que tomar
decisiones; o quizás dependiendo de los atributos.
<xsl:param name=‘nombre_parámetro' />
Supongamos el siguiente archivo libros.xml

<?xml-stylesheet type="text/xsl" href="libros.xsl"?>
<libros>
<libro>
<titulo>Fuente Ovejuna</titulo>
<autor>Lope de Vega</autor>
<isbn>84-9815-002-7</isbn>
<precio>24</precio>
</libro>
<libro>
<titulo>La Celestina</titulo>
<autor>Fernando de Rojas</autor>
<isbn>84-96390-96-9</isbn>
<precio>32</precio>
</libro>
<libro>
<isbn>84-9815-002-7</isbn>
<precio>56</precio>
</libro>
<libro>
<isbn>84-9815-002-7</isbn>
<precio>22</precio>
</libro>
</libros>
Nuestra hoja de estilos libros.xsl debe cumplir la condición de generar un listado de libros, pero siempre
y cuando, estos, tengan un precio superior un valor proporcionado como parámetro.
XML 28/34
I.E.S. Trassierra
<?xml version="1.0" encoding=“ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:param name="paraPrecio"/>
<html>
<body>
<h1>Mis Libros</h1>
<xsl:for-each select="libros/libro">
<xsl:if test="precio > $paraPrecio ">
Titulo:<xsl:value-of select="titulo"/><br/>
Autor:<xsl:value-of select="autor"/><br/>
Precio:<xsl:value-of select="precio"/><br/>
</xsl:if>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Si se usa la hoja de estilo dentro de un entorno de publicación, habrá que pasarle los parámetros al
documento XML, bien directamente desde el URL o desde un formulario, algo así:
http://misitio.com/libros.xml?paraPrecio=50.
Elemento <xsl:copy-of>
Se utiliza para copiar un conjunto de nodos del documento origen, al documento resultado de la
transformación. Se copiarán todos los nodos hijos y los atributos (en el caso de los elementos que los
tengan). Este elemento es especialmente útil cuando se quiere convertir un documento XML a otro
documento XML con una estructura diferente. El elemento <xsl:copy-of> irá acompañado por un
atributo select que toma como valor una expresión que determinará los nodos que se van a copiar. Este
elemento se puede utilizar para copiar en el documento resultado el valor de una variable. En este caso,
se escribirá como valor del atributo select el nombre de la variable precedido por el carácter $.
Ejemplo
Sea el archivo repertorio.xml:

<?xml-stylesheet type="text/xsl" href="repertorioX.xsl"?>
<repertorio>
<libro>
<titulo>Don Quijote de la Mancha</titulo>
<autor>Miguel de Cervantes</autor>
<anno-pub>1987</anno-pub>
<isbn>84-568-94-3</isbn>
</libro>
<libro>
<titulo>La Galatea</titulo>
<isbn>84-568-9424</isbn>
</libro>
<libro>
<isbn>84-568-95-12</isbn>
</libro>
</repertorio>
XML 29/34
I.E.S. Trassierra
Usaremos el archivo repertorio1.xsl para realizar la transformación deseada:

<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
<repertorio>
<xsl:copy-of select="//libro[starts-with(autor, 'Miguel de Cervantes')]" />
</repertorio>
</xsl:template>
</xsl:stylesheet>
Esto daría como resultado el fichero siguiente:

<repertorio>
<libro>
<titulo>Don Quijote de la Mancha</titulo>
<isbn>84-568-94-3</isbn>
</libro>
<libro>
<titulo>La Galatea</titulo>
<isbn>84-568-9424</isbn>
</libro>
</repertorio>
Como se aprecia, se ha generado un nuevo fichero HTML con la copia de los elementos
correspondientes a "Miguel de Cervantes".
Elemento <xsl:copy>
Similar al elemento anterior, se utiliza para copiar elementos, pero no se copiarán sus atributos ni sus
elementos hijos. Cuando se aplica sobre elementos, se copia el elemento, pero no su valor.
Ejemplo
En este ejemplo, se crea un elemento autor vacío en el documento destino, para cada elemento autor
existente en el documento original. Archivo repertorio2.xsl

<repertorio>
<xsl:apply-templates select="//autor" />
</repertorio>
</xsl:template>
<xsl:template match="autor">
<xsl:copy />
</xsl:template>
</xsl:stylesheet>
XML 30/34
I.E.S. Trassierra
Para copiar el valor de los elementos autor, habría que modificar el archivo XSLT. Archivo
repertorio3.xsl

<repertorio>
<xsl:apply-templates select="//autor" />
</repertorio>
</xsl:template>
<xsl:template match="autor">
<xsl:copy>
<xsl:value-of select="." />
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
Elemento <xsl:call-template>
Sirve para llamar a templates directamente por un nombre sin necesidad de que este esté relacionado
con un elemento XML. También podemos pasar parámetros con: <xsl:with-param name="range"
select="valor"/> y recogerlo en el template de la siguiente manera <xsl:param name="range" />
Contar marcas
Para contar el número de marcas existentes en un documento utilizaremos la función count(marca).
Por ejemplo si queremos contar el número de alumnos de un curso y estamos dentro de un template
con un match=”curso” escribiríamos algo así:
<xsl:variable name=”numAlumnos” select=”count(alumno)”/>
Filtrando la salida
Podemos filtrar la salida añadiendo un criterio de selección. Los posibles operadores de filtro a usar son:
 = (igual)
 != (distinto)
 < (menor que)
 > (mayor que)
Por ejemplo: <xsl:for-each select="catalog/cd[artist='Bob Dylan']">, seleccionaría aquellos cd cuyo

artista es 'Bob Dylan'.
XML 31/34
I.E.S. Trassierra
CSS + XSL sobre ficheros XML

Podemos aplicar formatos a los ficheros XML usando conjuntamente la transformación XSL y CSS.
Veamos un ejemplo: Partimos de nuestro fichero libros.xml

<?xml-stylesheet type="text/xsl" href="libros5.xsl"?>
<libros>
<libro>
<isbn>84-9815-002-7</isbn>
<precio>24</precio>
</libro>
<libro>
<isbn>84-96390-96-9</isbn>
<precio>32</precio>
</libro>
<libro>
<isbn>84-9815-002-7</isbn>
<precio>56</precio>
</libro>
<libro>
<isbn>84-9815-002-7</isbn>
<precio>22</precio>
</libro>
</libros>
Le aplicamos una transformación XSL y, a su vez, este fichero enlazará con una hoja de estilos CSS.

<xsl:template match="libros">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<link rel="stylesheet" type="text/css" href="estilo.css" />
<title>Ejemplo de XST</title>
<!- - <style type="text/css">
.estilo1 {
color:red;
}
</style> - ->
</head>
<body>
<h1> Mi primer documento XSLT </h1>
<strong class="estilo1">Titulo:</strong>
<xsl:value-of select="libro/titulo"/><br/>
<strong class="estilo1">Autor:</strong>
<xsl:value-of select="libro/autor"/>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XML 32/34
I.E.S. Trassierra
Como se puede ver, podemos enlazar la hoja de estilos en cascada o bien, incrustar el estilo mediante la
etiqueta <style>. En ambos casos el resultado es idéntico.
Haciendo uso de atributos <xsl:attibute> podemos conseguir algo como esto. Sea el archivo
reclamaciones.xml
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="reclamaciones.xsl"?>
<reclamaciones-poliza>
<poliza tipo="contenidos">
<titular-poliza>A. López</titular-poliza>
<reclamaciones>
<reclamacion>
<año>2002</año>
<detalles>Robo de TV</detalles>
</reclamacion>
</reclamaciones>
</poliza>
<titular-poliza>V. Serrano</titular-poliza>
</poliza>
<poliza tipo="edificios">
<titular-poliza>C. Jiménez</titular-poliza>
<reclamaciones>
<reclamacion>
<año>2004</año>
<detalles>Daños de fuego en cocina</detalles>
</reclamacion>
</reclamaciones>
</poliza>
<titular-poliza>D. Urrutia</titular-poliza>
<reclamaciones>
<reclamacion>
<año>1998</año>
<detalles>Robo de bicicleta</detalles>
</reclamacion>
<reclamacion>
<año>2005</año>
<detalles>Rotura de jarrón Ming</detalles>
</reclamacion>
</reclamaciones>
</poliza>
<poliza tipo="edificios">
<titular-poliza>E. Toledo</titular-poliza>
</poliza>
</reclamaciones-poliza>
A partir del archivo reclamaciones.xsl vamos conseguir, mediante el uso de atributos, poder usar una
hoja de estilos en cascada, obteniendo la información para la misma del propio archivo XML
XML 33/34
I.E.S. Trassierra
Archivo reclamaciones.xsl
<?xml version="1.0"?>
<html>
<head>
<title>Reclamaciones de Seguros</title>
<link rel="stylesheet" type="text/css" href="estilo-poliza.css" />
</head>
<body>
<h1>Demandantes y tipos de pólizas</h1>
<br/>
<xsl:for-each select="reclamaciones-poliza/poliza">
<p><xsl:attribute name="class">
<xsl:value-of select="@tipo"/>
</xsl:attribute>
Nombre: <xsl:value-of select="titular-poliza"/>
</p>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Usaremos el archivo estilo-poliza.css
.contenidos {color:blue;backgroud-color:black}
.edificios {color:black;backgroud-color:yellow}
XML 34/34

Ud13 XSL PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ud13 XSL PDF

Cargado por

Copyright:

Formatos disponibles

I.E.S.

Desarrollo de Aplicaciones Web

Módulo Profesional de Lenguajes de Marcas y

Unidad 13 - EXtensible Stylesheet Language

 XPath. Lenguaje de navegación para referirse a partes de un documento XML.

XPath: XML Path language

Árbol del documento

Nota: La declaración DOCTYPE no se considera como nodo.

Por ejemplo, el documento primero.xml siguiente:

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

se puede representar mediante el siguiente grafo:

Sintaxis de las expresiones XPath

Las expresiones XPath se pueden escribir de dos formas distintas:

Eje (en inglés, axis)

 /..: indica el elemento padre.

Predicado (en inglés, predicate)

 [@atributo]: selecciona los elementos que tienen el atributo.

 [condicion]: selecciona los nodos que cumplen la condición.

En el caso de las cadenas numéricas, las comillas son optativas.

La condición puede utilizar el valor de un atributo (utilizando @) o el texto que contiene el

En los ejemplos siguientes se obtienen respectivamente los elementos <fechaPublicacion> cuyo

Un predicado puede contener condiciones compuestas. En los ejemplos siguientes se seleccionan,

Selección de nodos (en inglés, node test)

 /text(): selecciona únicamente el texto contenido en el nodo.

 /*: selecciona todos los hijos (sólo elementos) del nodo.

 /@*: selecciona todos los atributos del nodo.

XSLT: Transformaciones XSL

 El documento XML es el documento inicial a partir del cual se va a generar el resultado.

Hojas de estilo XSLT

Estas etiquetas son:

Estas etiquetas son

Enlazar documentos XML con hojas de estilo XSLT

<?xml version="1.0" encoding='ISO-8859-1'?>

Para convertirlo en HTML, usaremos la siguiente hoja de estilo (tienda-html.xsl):

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

Explicación del código

<?xml version="1.0" encoding='ISO-8859-1'?>

Este se transforma con la siguiente hoja XSLT (tienda1-html.xsl):

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

El orden en el que se incluyen los elementos en la salida es el mismo en el que se encuentran en la

El resultado al verlo en el navegador Web será:

Como vemos, hay dos dormas de aplicar una plantilla:

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

Plantillas vacías o no existentes

Aplicar reglas a subnodos: la instrucción <xsl:apply-templates>

La sintaxis de este elemento es:

Veamos otro ejemplo: estudiantes2.xsl.

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

<xsl:template match = "clases/estudiante">

<xsl:template match = "@nunmatri">

<xsl:template match = "nombre">

<xsl:template match = "apellido">

<xsl:template match = "nick">

<xsl:template match = "calificacion">

La salida que obtendremos será algo como esto:

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

Ejemplo: Modificar el bucle for-each anterior por el siguiente y comprobar la salida.

Añadir al fichero XML las siguientes ciudades, al final del mismo:

El elemento <xsl:if test>

Ejemplo: Modifica el bucle for-each anterior por el siguiente y comprueba la salida.

El elemento <xsl:choose> (<xsl:when> y <xsl:otherwise>)

La salida obtenida será algo como esto: