Guia Prática sobre XSLT

Curso rápido da Visie – Ensinando os melhores Introdução ao XSLT da Visie P. 1

Curso rápido de XSLT

visie.com.br tableless.com.br


Curso rápido de XSLT

Visie Padrões Webvisie.com.br/cursos/

http://visie.com.br/cursos

Introdução ao XSLT

Abram alasXML é uma metalinguagem de marcação de dados, uma linguagem para se criar novas linguagens. As linguagens criadas com XML são chamadas de subconjuntos de XML. Atom e RSS, usadas para distribuir conteúdo online de forma automática, são dois exemplos. SVG, para criação de grá!cos vetoriais, é outro exemplo.

Muito se tem falado de XML e da forma como essa linguagem vai revolucionar a internet, nos dando a Web Semântica e nossos dados em qualquer lugar. Mas pouca gente está de fato trabalhando com XML na prática e muita gente começou a estudar o assunto, aprendeu a escrever um arquivo XML e !cou se perguntando o que fazer com isso.Precisamos então de um cenário prático, um caso "do mundo real", para que nosso estudo não seja apenas uma teoria vaga que você acha interessante mas não sabe exatamente pra que serve.

XML na práticaVamos analisar alguns exemplos de trabalho com dados em que XML parece ser uma resposta bastante natural:

Tabela de preçosO website de uma escola, em PHP, precisa exibir logo abaixo de sua tabela de preços de matrícula e mensalidades, a tabela de preços dos materiais escolares extraída do site de uma papelaria parceira, que é feito em Java. Os desenvolvedores do site da papelaria preparam então um aplicativo que atualiza um arquivo XML em seu servidor. Você pode com facilidade usar a função fopen do PHP para obter este XML. Seu trabalho é então processá-lo para transformá-lo em uma tabela de preços HTML.

Calendário de EntrevistasUma pequena empresa de recursos humanos envia candidatos escolhidos para uma empresa parceira, de grande porte. A empresa maior marca uma entrevista individual num dia e horário determinado para cada candidato, e fornece um arquivo xml com a agenda de entrevistas de todos os candidatos de todas as empresas parceiras. O site da empresa menor, feito em Java/JSP, precisa exibir uma agenda, em HTML, apenas das entrevistas dos candidatos indicados por ela.

Gerenciador de ConteúdosEis um caso real! O gerenciador de conteúdos da Iônia, indústria de cosméticos, gera um XML do conteúdo, como você pode ver em http://www.ionia.com.br/xml.asp. Você precisa transformar este conteúdo em um bonito site HTML.


XSLT é um subconjunto de XML usado para transformar um formato de XML em outro. Torna fácil tarefas como, por exemplo, gerar um grá!co (SVG) a partir de uma tabela publicada em seu site (XHTML).

XSL, XSLT e seus usosA linguagem XSL nasceu composta por três partes:

Xpath - Linguagem de localização de elementos em um arquivo XML. É a primeira que vamos estudarXSLT - Linguagem de transformação de XML, é esta que faz a mágica toda.XSL-FO - Linguagem de formatação XML. Ainda não há implementações populares de XSL-FO e seu uso por enquanto é muito restrito.

Como eram três linguagens distintas, com objetivos diferentes, que compunham a XSL, o W3C mudou a especi!cação antes de aprová-la, e hoje a linguagem XSL-FO passou a se chamar XSL (e a antiga XSL, que englobava as três, não ganhou nome). Apesar disso é conviente notar que, uma vez que XSL (XSL-FO) ainda não foi adotada pelo mercado, seus usos hoje ainda são muito restritos e ela é praticamente deconhecida dos desenvolvedores, quando as pessoas dizem "XSL" ou "XSLT" hoje elas geralmente querem dizer a mesma coisa: XSLT.

O que exatamente faz a XSLT? Observe o diagrama a seguir:

Diagrama XSLTOu seja, tendo um arquivo XML de origem (que nos nossos três exemplos já foram fornecidos por terceiros) o papel da XSLT é transformar esse arquivo em um outro formato, HTML, XML, PDF ou outro. Assim, tendo um interpretador XML que suporte XSLT, nos nossos três exemplos bastaria escrever um arquivo XSLT que transformasse nossos dados em HTML.

A maioria dos ambientes de desenvolvimento hoje oferece interpretadores de XML com suporte a XSL.


Recomendamos:

● PHPO PHP já vem com uma extension que trabalha com XSLT. Veja mais em: http://br2.php.net/manual/pt_BR/ref.xslt.php

● JavaUse o Jax:http://java.sun.com/xml/

● PythonExperimente a libxslt:http://xmlso#.org/XSLT/python.html

● ASPUse os componentes do pacote MSXML, versão 3 ou superior.

Para demonstrar como é simples usar um interpretador XML para XSLT, segue um exemplo de como fazer a transformação em ASP:

'Transforma o codigoxml usando o arquivoxsl

function transforma(codigoxml,arquivoxsl)

'Cria os objetos necessários

set xmldoc = Server.CreateObject("MSXML2.FreeThreadedDOMDocument.3.0")

set xsldoc = Server.CreateObject("MSXML2.FreeThreadedDOMDocument.3.0")

set xslt = Server.CreateObject("MSXML2.XSLTemplate")

'Carrega o XML

xmldoc.LoadXML(codigoxml)

'Carrega o arquivo XSLT

xsldoc.async = False

xsldoc.Load(arquivoxsl)

Set xslt.stylesheet = xsldoc

Set xslproc = xslt.createProcessor()

'Executa a transformação

xslproc.input = xmldoc

xslproc.transform

transforma = xslproc.output

end function

Como você pode ver, o código é simples, e precisa ser escrito uma única vez.


http://br2.php.net/manual/pt_BR/ref.xslt.php

http://xmlsoft.org/XSLT/python.html





Documentos XML

Documentos XML são árvoresObserve o seguinte documento XML, que poderia servir para nosso primeiro exemplo:

<?xml version="1.0"?>

<loja>

<categoria id="1" description="Cadernos">

<produto id="11">

<descricao>Caderno Univ. 100 folhas</descricao>

<preco>25.80</preco>

</produto>

<produto id="12">

<descricao>Caderno Univ. 10 mat.</descricao>


</produto>

</categoria>

<categoria id="2" description="Reguas">

<produto id="21">

<descricao>Regua Comum, 20cm</descricao>

<preco>0.80</preco>

</produto>

<produto id="22">

<descricao>Esquadro 15x20cm</descricao>

<preco>1.10</preco>

</produto>

</categoria>

</loja>


Veja o que acontece quando abro esse arquivo em um editor de XML inteligente, como o Quanta Plus:

Como você pode ver, o Quanta tem um interpretador de XML que leu meu arquivo e organizou os dados numa estrutura de árvore. Cada elemento naquela estrutura é chamado de nó. Existem três tipos de nós:

● Elementos Cada tag do XML é um elemento. O primeiro elemento, loja, envolve todos os outros e é chamado de elemento-raiz.

● Atributos Embora não sejam mostrados pelo TreeView do Quanta, os atributos de cada elemento também são nós na estrutura do XML.

● TextoComo você pode ver na !gura, o texto de cada elemento representa um nó separado do próprio elemento.

(Na verdade exitem mais de três tipos de nós. Os comentários, por exemplo, também são nós do XML. Mas para nosso estudo agora bastam estes três tipos.)Os nós contidos por um elemento são chamados de !lhos (e o elemento que os contém de pai, claro.) Os nós !lhos de um mesmo pai e que estão no mesmo nível são chamados de adjacentes, como descricao e preco.


XPathXPath é a linguagem usada para localizar nós no arquivo XML. É bastante abrangente, possuindo muitos recursos de seleção e funções. Para este tutorial vamos nos ater aos recursos básicos da linguagem. Se você quiser estudá-la a fundo, um bom lugar é http://www.w3schools.com/xpath/.

O melhor meio de começar a entender XPath é através de exemplos práticos. Vamos ao básico:

/loja

O código acima selecionaria, no documento de exemplo, o elemento-raiz loja. Veja este agora:

/loja/categoria/produto

Como você pode ver, a estrutura é semelhante à da construção de URLs em diretórios. Aqui selecionamos todos os elementos produto que estão dentro de um elemento categoria dentro do elemento raiz loja.Também você pode notar que sempre começamos nossa seleção no elemento-raiz (/). Dentro da XSLT você vai precisar usar XPath para selecionar elementos iniciando de um outro nó qualquer. O nó de onde você começa sua seleção é chamado de nó de contexto. Assim, se o nó de contexto, o nó de onde estivermos iniciando, for um elemento categoria e quisermos selecionar os precos de seus produtos:

produto/preco

Note a ausência da barra inicial. Isso faz com que a comece no nó de contexto e não no elemento raiz. Você também pode subir níveis. Digamos de o nó de contexto seja um elemento preco e queiramos selecionar as categorias:

../../../categoria

Outro truque interessante:

/loja//produto

Este código localiza todos os produtos dentro de loja, não importa quantos níveis abaixo. Ou seja, ao usar // o interpretador varre toda a árvore de !lhos do elemento procurando por elementos coincidentes. Outro exemplo interessante:


http://www.w3schools.com/xpath/



/loja/*

Este código seleciona qualquer elemento imediatamente dentro de loja. O asterisco signi!ca "qualquer elemento".Vamos começar a complicar isso. Podemos usar colchetes para fazer testes:

//produto[2]

Este código seleciona o segundo produto em cada categoria. A explicação é óbvia. Um número dentro dos colchetes seleciona o elemento com aquele índice, assim elemento[3] seleciona o terceiro elemento. Veja este agora:

//produto[preco]

Este código seleciona todos os elementos produto que contém um elemento preco. Podemos usar testes de nó mais complexos dentro dos colchetes:

//categoria[produto/preco]

Este código seleciona todas as categorias que contém um elemento produto contendo um elemento preco. Veja este agora:

//produto[preco=0.80]

Este código seleciona todos os produtos que contém um elemento preco com valor 0.80, ou seja, todos os produtos que custam 80 centavos. A XPath também nos fornece funções que podemos invocar, por exemplo:

count(//produto)

Retorna o valor 4, o número de elementos produto. A função last(), por exemplo, retorna o índice do último elemento.

Assim, podemos fazer:

/loja/categoria[last()]


Que selecionará a última categoria. Podemos também concatenar vários métodos de seleção:

/*/categoria[last()]/produto[preco>1]/descricao

Seleciona a descrição dos produtos mais caros que R$1,00 na última categoria. Você também pode selecionar nós em caminhos diferentes separando-os com o caractere de pipe, assim:

//produto/descricao | //produto/preco


AtributosA sintaxe para a seleção de atributos é @atributo, assim:

/loja/categoria[1]/@id

O código acima seleciona o atributo id do primeiro elemento categoria. Você também pode usar atributos nos colchetes de teste, por exemplo:

/loja/categoria[@id=1]/produto[@id]/preco

Esse código seleciona os elementos preco dentro dos elementos produto que possuem um atributo id dentro da categoria cujo id tem valor 1.Expressões e funções

Os operadores disponíveis para a XPath são os seguintes:

Operadores Descrição+ Adição numérica. 2+3 retorna o valor 5

- Subtração numérica. 3-2 retorna o valor 1.

* Multiplicação numérica. 2*3 retorna o valor 6.

div Divisão numérica. O sinal de / não é utilizado porque ele já é usado para de!nir caminhos (/loja/categoria por exemplo.) 6 div 2 retorna o valor 3.

mod Resto. 11 mod 5 retorna o valor 1.

= Igualdade. 2=2 retorna true e 2=3 retorna false.

!= Diferença. 2!=2 retorna false e 2!=3 retorna true.

< <= > >=Comparadores numéricos. Em um arquivo XSLT, a!m de escrever um XML válido, troque os operadores < e <= por < e <=.

and or Operadores lógicos and e or.

Veja um exemplo de código com operadores:

/loja/categoria[@id!=2]/produto[preco>1 and @id!=11]

Você pode encontrar uma referência bastante completa das funções disponíveis na XSLT em http://www.w3schools.com/xpath/xpath_functions.asp


http://www.w3schools.com/xpath/xpath_functions.asp



Vamos dar uma olhada nas mais comuns:

● count(nodes)Retorna o número de nós em nodes.

● last()Retorna o índice do último elemento no conjunto de nós atual.

● name(node)Retorna o nome da tag de node.

● position()Retorna o índice do nó de conteto atual.

● contains(str1,str2)Testa se str1 contém str2 e retorna true ou false

● starts-with(str1,str2)Testa se str1 começa com str2 e retorna true ou false

● round(num)Arredondada num para o inteiro mais próximo

● not(exp)Retorna true se exp for false e vice-versa

● number(var)Converte var para um número

● string(var)Converte var para uma string

● boolean(var)Converte var para um boolean


TransformandoTodo arquivo XSLT é um arquivo XML válido, tendo como elemento raiz um elemento stylesheet ou um elemento transform sob o namespace "http://www.w3.org/1999/XSL/Transform". Os elementos stylesheet e transform fazem exatamente a mesma coisa, e você pode usar um ou o outro, a seu critério. Como o elemento stylesheet é mais usado, recomendamos que você o use, por mera convenção. Vamos fazer nossos exemplos com ele. Assim, o arquivo XSLT básico, o mais simples que pode haver:


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

</xsl:stylesheet>

templateO código acima varre todo o arquivo XML, começando pelo nó raiz, elemento por elemento, listando o texto de cada elemento. Se o aplicarmos ao XML da loja o resultado será:

Caderno Univ. 100 folhas25.80Caderno Univ. 10 mat.33.50Regua Comum,

20cm0.80Esquadro 15x20cm1.10

Ou seja, apenas o texto de todos os elementos. Nós podemos mudar este comportamento. Listar apenas o texto de cada elemento é chamado de "template padrão". Podemos criar outro template para o elemento que desejarmos. Por exemplo, se quisermos que o XSLT retorne a palavra "Produto" ao encontrar cada elemento produto podemos fazer:



<xsl:template match="produto">Produto

</xsl:template>

</xsl:stylesheet>

Aqui alteramos o template padrão para outro, contendo a palavra Produto e uma quebra de linha. Ao aplicarmos esse XSLT o resultado será:

ProdutoProdutoProdutoProduto

apply-templatesVocê deve ter notado acima que foi gerada a palavra "Produto" para cada um dos produtos encontrados e o


interpretador não continunou a descer nos níveis dentro de produto. Ou seja, quando você cria um template próprio para uma tag o interpretador aplica o seu template e não continua aplicando os templates para os elementos !lhos. Para que o interpretador considere também os !lhos do elemento para o qual você criou um template você deve usar o elemento apply-templates. Veja:



<xsl:template match="produto">

Produto: <xsl:apply-templates />

</xsl:template>

</xsl:stylesheet>

Aqui, ao encontrar cada um dos produtos, o interpretador vai escrever "Produto:" e em seguida aplicar o template padrão para preco e descricao, o que resultará em:

Produto: Caderno Univ. 100 folhas25.80Produto: Caderno Univ. 10 mat.33.50Produto: Regua Comum, 20cm0.80Produto: Esquadro 15x20cm1.10

O atributo match aceita qualquer expressão XPath. Você também pode aplicar um template personalizado para os elementos !lhos:




Produto: <xsl:apply-templates />

</xsl:template>

<xsl:template match="preco"> [Preço oculto]</xsl:template>

</xsl:stylesheet>

Aqui, ao encontrar um elemento descricao o interpretador vai aplicar o template padrão, mas ao encontrar um elemento preco vai aplicar o template personalizado, gerando o seguinte:

Produto: Caderno Univ. 100 folhas [Preço oculto]Produto: Caderno Univ. 10 mat. [Preço oculto]Produto: Regua Comum, 20cm [Preço oculto]Produto: Esquadro 15x20cm [Preço oculto]Você pode escolher que templates serão aplicados ao colocar um apply-template, através do atributo select, que aceita XPath:





Produto: <xsl:apply-templates select="descricao" /> Preço: <xsl:apply-templates

select="preco" />

</xsl:template>

</xsl:stylesheet>

O código acima resulta em:

Produto: Caderno Univ. 100 folhas Preço: 25.80Produto: Caderno Univ. 10 mat. Preço: 33.50Produto: Regua Comum, 20cm Preço: 0.80Produto: Esquadro 15x20cm Preço: 1.10

Que tal tentar gerar uma tabela HTML com o que aprendemos até aqui? Veja um exemplo:



<xsl:template match="loja">

<h1>Tabela de Preços</h1>

<table>

<tr>

<th>Produto</th><th>Preço</th>

</tr>

<xsl:apply-templates />

</table>

</xsl:template>


<tr>

<td><xsl:apply-templates select="descricao" /></td>

<td><xsl:apply-templates select="preco" /></td>

</tr>

</xsl:template>

</xsl:stylesheet>

Aqui temos dois templates. O primeiro, executado quando o interpretador encontra o elemento loja, cria um título para a página (h1), inicia a tabela e cria a primeira linha, com os cabeçalhos "Produto" e "Preço". O segundo template, executado em todos os produtos, cria uma linha da tabela com os valores de descricao e preco, um em


cada célula. Veja como !cou o resultado quando visto em um navegador:

copy-ofSuponha que você queira copiar um elemento inteiro, todo o seu código XML, e não apenas seu texto. É fácil:




<xsl:copy-of select="categoria[1]" />

</xsl:template>

</xsl:stylesheet>

Este código copia o código XML da primeira categoria, resultando em:

<categoria id="1" description="Cadernos">

<produto id="11">

<descricao>Caderno Univ. 100 folhas</descricao>


</produto>

<produto id="12">

<descricao>Caderno Univ. 10 mat.</descricao>


</produto>

</categoria>

Se a expressão XPath no atributo select selecionar mais de um elemento o copy-of listará o código XML de todos os elementos selecionados seqüencialmente, um após o outro.value-of

O elemento value-of da XSLT exibe o retorno de um valor XPath. Ou seja, ele avalia uma expressão XPath. Se o resultado dessa expressão for um número, string ou valor booleano, ele o exibe. Se for um atributo, exibe o valor do atributo. Se for um conjunto de nós, exibe o texto do primeiro nó. Veja este exemplo:





Produto:

<xsl:value-of select="@id" />. <xsl:value-of

select="descricao" /> - R$<xsl:value-of select="preco" />

</xsl:template>

</xsl:stylesheet>

Que gera o seguinte:Produto:11. Caderno Univ. 100 folhas - R$25.80Produto:12. Caderno Univ. 10 mat. - R$33.50Produto:21. Regua Comum, 20cm - R$0.80Produto:22. Esquadro 15x20cm - R$1.10Aqui, ao encontrar um elemento produto o interpretador escreveu "Produto:", o valor do atributo id, um ponto, o valor da descricao, o texto "- R$" e o valor do preco. Vamos tentar gerar uma tabela HTML mais completa agora, com o que aprendemos?





<table border="1">


</table>

</xsl:template>

<xsl:template match="categoria">

<tr>

<th colspan="3"><h3><xsl:value-of select="@description" /></h3></th>

</tr><tr>

<th>Cód.</th><th>Descrição</th><th>Preço</th></tr>


</xsl:template>


<tr>

<td><xsl:value-of select="@id" /></td>


<td><xsl:value-of select="descricao" /></td>

<td><xsl:value-of select="preco" /></td>

</tr>

</xsl:template>

</xsl:stylesheet>

Vou deixar para você o privilégio de entender o código acima. Veja como !ca o HTML gerado, quando visto no navegador:

attributeImagine agora que queremos colocar, em cada linha da nossa tabela de produtos, um link para a página detalhes_produto.asp?cod={código do produto}. Essa é na verdade uma situação muito comum. O código HTML para fazê-lo deve !car, para o produto de id 11.

Como inserir o código do produto dentro do atributo href? Através do elemento attribute, observe:



<xsl:template match="/">

<img>

<xsl:attribute name="src">logo.gif</xsl:attribute>

</img>

</xsl:template>

</xsl:stylesheet>

Este código gera:

<img xsrc="logo.gif" />


Ou seja, o elemento attribute modi!ca seu elemento-pai, inserindo nele um atributo. O nome do atributo gerado será o valorde name e o valor do atributo gerado será o conteúdo do elemento attribute. Veja agora:




<img align="left">

<xsl:attribute name="src">logo.gif</xsl:attribute>

<xsl:attribute name="border">0</xsl:attribute>

</img>

</xsl:template>

</xsl:stylesheet>

Que gera:

<img align="left" xsrc="logo.gif" border="0" />

Ou seja, podemos combinar atributos escritos diretamente no elemento com elementos attribute. Agora veja:




<div>

<xsl:attribute name="id">sep1</xsl:attribute>

Teste

<xsl:attribute name="class">sep</xsl:attribute>

</div>

</xsl:template>

</xsl:stylesheet>

Vai gerar:

<div id="sep1">

Teste

</div>

Ou seja, o interpretador vai ignorar elementos attribute se eles não estiverem no início do elemento-pai, antes do conteúdo.Podemos inserir outros elementos XSL dentro do elemento attribute, o que resolve nosso problema da listagem de produtos com links, veja:






<table border="1">


</table>

</xsl:template>


<tr>


</tr><tr>

<th>Cód.</th><th>Descrição</th><th>Preço</th>

</tr>


</xsl:template>


<tr>


<td>

<a><xsl:attribute

name="href">detalhes_produto.asp?cod=<xsl:value-of

select="@id" /></xsl:attribute><xsl:value-of

select="descricao" /></a>

</td>

<td><xsl:value-of select="preco" /></td>

</tr>

</xsl:template>

</xsl:stylesheet>


E veja como !ca o HTML gerado, visualizado em seu navegador:

call-templateUma outra maneira de se chamar um template, dando-lhe um nome, assim:




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

</xsl:template>

<xsl:template name="pr">

<xsl:value-of select="descricao" />

- R$ <xsl:value-of select="preco" /> |

</xsl:template>

</xsl:stylesheet>

Aqui usamos o elemento <i>call-template</i> para chamar o segundo template pelo nome. Note que o nó de contexto ao chamar o segundo template é o mesmo do primeiro (produto).

ifO código do elemento if é bastante simples:






- R$ <xsl:value-of select="preco" />

<xsl:if test="preco>2"> Pague em 3X no cartão!</xsl:if> |

</xsl:template>

</xsl:stylesheet>

Que resulta em:

Caderno Univ. 100 folhas- R$ 25.80 Pague em 3X no cartão! |Caderno Univ. 10 mat.- R$ 33.50 Pague em 3X no cartão! |Regua Comum, 20cm- R$ 0.80 |Esquadro 15x20cm- R$ 1.10 |

Ou seja, ao encontrar um elemento if o interpretador vai avaliar a expressão XPath test. Se o resultado for verdadeiro, ele executa o que há dentro do elemento if, caso contrário o ignora. Vamos, com isso, inserir mais um recurso em nossa tabela de preços:





<table border="1">


</table>

</xsl:template>


<tr>


</tr><tr>


</tr>


</xsl:template>


<tr>



<td>

<a><xsl:attribute




</td>

<td>

R$ <xsl:value-of select="preco" />

<xsl:if test="preco < 2">

<b> Promoção!</b>

</xsl:if>

</td>

</tr>

</xsl:template>

</xsl:stylesheet>

Veja como !cou o código gerado, quando visto em seu navegador:

chooseO elemento choose funciona de maneira semelhante ao if, dando-nos porém mais "exibilidade. Veja:







<xsl:choose>

<xsl:when test="preco < 1"> | Promoção!</xsl:when>

<xsl:when test="preco < 2"> | Preço bom!</xsl:when>

<xsl:otherwise> | 3X no cartão!</xsl:otherwise>

</xsl:choose>|

</xsl:template>

</xsl:stylesheet>

E seu resultado:

Caderno Univ. 100 folhasR$ 25.80 | 3X no cartão! |

Caderno Univ. 10 mat.R$ 33.50 | 3X no cartão! |

Regua Comum, 20cmR$ 0.80 | Promoção! |

Esquadro 15x20cmR$ 1.10 | Preço bom! |

Ao encontrar um elemento choose o interpretador executa o test no primeiro elemento when. Se for verdadeiro, executa o conteúdo deste when, caso contrário testa o próximo. Se nenhum dos testes when for verdadeiro o interpretador executará o conteúdo do bloco otherwise, se houver. Veja o que vamos fazer com nossa tabela de preços:





<table border="1">


</table>

</xsl:template>



<tr>


</tr><tr>


</tr>


</xsl:template>


<tr>


<td>

<a><xsl:attribute




</td>

<td>


<xsl:choose>

<xsl:when test="preco < 1">

<b> Promoção!</b>

</xsl:when>

<xsl:when test="preco < 2">

<b> Preço bom!</b>

</xsl:when>

<xsl:otherwise>

<b> 3X no cartão!</b>

</xsl:otherwise>

</xsl:choose>

</td>

</tr>

</xsl:template>

</xsl:stylesheet>

Veja como !ca o HTML gerado:


for-eachVocê pode substituir a chamada um template com um elemento for-each, veja:




== <xsl:value-of select="@description" /> ==

<xsl:for-each select="produto">

- <xsl:value-of select="descricao" /> -

</xsl:for-each>

</xsl:template>

</xsl:stylesheet>

Veja o resultado:

== Cadernos ==- Caderno Univ. 100 folhas -- Caderno Univ. 10 mat. -== Reguas ==- Regua Comum, 20cm -- Esquadro 15x20cm -

A dica é: você pode usar for-each para simpli!car o código e não precisar escrever um número enorme de templates para fazer coisas simples. Se o conteúdo do for-each for complexo, ou você for reutilizá-lo em outros lugares, escreva-o num template separado e não num for-each.

sortProvavelmente você estava se perguntando se não havia um meio de ordenar os dados. Há. Veja:





<xsl:apply-templates select="categoria/produto">

<xsl:sort select="descricao" order="descending" />

</xsl:apply-templates>

</xsl:template>



</xsl:template>

</xsl:stylesheet>

E veja o resultado:

- Regua Comum, 20cm -- Esquadro 15x20cm -- Caderno Univ. 100 folhas -– Caderno Univ. 10 mat. -

Os principais parâmetros para o elemento sort são:

● selectUma expressão XPath retornando o valor a ordenar

● orderPode ser ascending (ascendente) ou descending (descendente). O default é ascending.

● data-typeO tipo de dado a ordenar, pode ser number ou text. O default é text.

O elemento sort também pode ser usado dentro de um elemento for-each, desde que seja o primeiro elemento. O código abaixo faz exatamente a mesma coisa que o anterior:




<xsl:for-each select="categoria/produto">

<xsl:sort select="descricao" order="descending" />



</xsl:for-each>

</xsl:template>

</xsl:stylesheet>

parâmetros (with-param, param)Um template XSL pode receber um parâmetro, assim:

...


<xsl:param name="codigo" />

Código: <xsl:value-of select="$codigo" />

</xsl:template>

...

E pode ser chamado assim:

<xsl:apply-templates select="//produto">

<xsl:with-param name="codigo" value="9" />

</xsl:apply-templates>

Seu documento XSL também pode receber um parâmetro, se o elemento param for colocado como !lho do elemento stylesheet, assim:



<xsl:param name="codigo" />


<xsl:for-each select="categoria/produto[@id=$codigo]">


</xsl:for-each>

</xsl:template>

</xsl:stylesheet>

O arquivo acima vai exibir a descrição do produto cujo id for recebido através do parâmetro "codigo". Você deve consultar a documentação de sua linguagem de programação ou de seu interpretador de XML para entender como passar parâmetros para um arquivo XSLT.


ImportaçãoVocê pode importar um arquivo XSL externo com:

<xsl:import href="d:xslcurso2.xsl" mce_href="d:xslcurso2.xsl" />

E pode mandar aplicar os templates importados com:

<xsl:apply-imports />

Você deve imaginar as possibilidades que isto lhe dá em termos de reuso de código e organização de templates.


Leitura RecomendadaLivro - XSLT: Interagindo com XML e HTMLO chinês é bom pra caramba. Ele ensina, com bons exemplos, a transformar XML em XML (WAP, SVG, etc), HTML, PDF, texto… e vem com um CDzinho com todos os exemplos. (432 páginas)

KHUN YEE FUNG - Editora Ciência ModernaISBN: 8573931655

Livro - XSLT: Referência do ProgramadorSeja uma enciclopédia ambulante de XSL. (672 páginas)MICHAEL KAY - Editora Alta BooksISBN: 8588745216


Copyright © 2007 Visie Padrões Web Ltda. Todos os direitos reservados. São Paulo - SP – Brasil

55-11-3477-3347

O Curso foi escrito por Elcio Ferreira (elcio.com.br).Diretor de Tecnologia da Visie, blogueiro, palestrante e desenvolvedor web.


Documents

Guia Prática sobre XSLT