• 20 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 23/09/2019

Les templates : aller plus loin

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans le chapitre précédent, nous avons vu un grand nombre de fonctions à utiliser dans nos templates. Ne nous arrêtons pas en si bon chemin, il nous reste encore quelques fonctions à voir ! Ces nouvelles fonctions seront également l'occasion d'aborder de nouveaux concepts à savoir, les variables et les paramètres.

Ce nouveau chapitre sera également l'occasion d'apprendre à créer et exécuter une transformation XSLT dans EditiX.

Les variables et la fonction call-template

Au cours de ce chapitre, je vous propose d'aborder une nouvelle notion bien connue en informatique et plus précisément dans les langages de programmation : les variables. Ce chapitre sera également l'occasion d'une mise en pratique de cette nouvelle notion à travers l'appréhension d'une nouvelle fonction pour nos templates : call-template.

Les variables

Définition

En XSLT, comme dans de nombreuses technologies informatiques et plus précisément dans les langages de programmation, il existe une notion importante que l'on appelle les variables.

Une variable est une information que l'on stocke dans la mémoire de l'ordinateur afin de pouvoir la réutiliser. Elle possède un identifiant unique qui est son nom. Ainsi, plusieurs variables ne peuvent pas avoir le même nom. L'information stockée par une variable est sa valeur.

Dans nos documents XSLT, les variables doivent être déclarées au sein d'un template et ont une portée dite locale, c'est-à-dire qu'une variable ne peut être utilisée que dans le template dans lequel elle est déclarée. Par exemple, si une variable portant le nom "maVariable" est déclarée dans un premier template, les autres templates du document XSLT ne la connaissent pas.

Déclaration et utilisation

Afin de déclarer une variable, il convient d'utiliser la fonction<xsl:variable />. Cette fonction accepte deux attributs :

  • Name : c'est le nom que l'on souhaite donner à notre variable, ce nom va nous permettre de l'identifier de manière unique.

  • Select : cet attribut optionnel accepte soit une expression XPath qui permet de sélectionner la valeur que l'on souhaite stocker dans notre variable, soit une chaîne de caractères.

La syntaxe pour déclarer une variable est donc la suivante :

<xsl:variable name="nom_de_la_variable" select="expression XPath|chaîne de caractères" />

Pour pouvoir utiliser une variable et récupérer la valeur qu'elle contient, il convient de faire précéder son nom par le symbole "$".

Exemple

Afin d'illustrer ce que nous venons d'apprendre sur les variables, je vous propose de voir ensemble quelques exemples. Dans notre premier exemple, nous allons créer une variable qui contiendra une chaîne de caractères et nous l'afficherons dans une balise paragraphe d'un document HTML :

<xsl:template match="/">
  <xsl:variable name="couleur" select="'rouge'" />
  
  <html>
    <head>
	  <title>Test des variables</title>
	</head>
	<body>
	  <p><xsl:value-of select="$couleur" /></p>
	</body>
  </html>			
</xsl:template>

Comme vous pouvez le constater, dans ce template, nous déclarons une variable qui s'appelle "couleur" et qui contient la chaîne de caractères "rouge" :

<xsl:variable name="couleur" select="'rouge'" />

Puisque la valeur "rouge" est une chaîne de caractères, il est impératif de la mettre entre ' (guillemets simples) afin de ne pas la confondre avec une expression XPath.

Pour pouvoir afficher la valeur contenue dans la variable dans notre document HTML, il suffit simplement de faire précéder son nom par le symbole $ :

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

Le document HTML produit par notre transformation est le suivant :

<!DOCTYPE html
  PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
   <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Test des variables</title>
   </head>
   <body>
    <p>rouge</p>
   </body>
</html>

A noter : il existe une autre façon de définir la valeur d'une variable lorsque celle-ci ne provient pas d'une expression XPath :

<xsl:variable name="nom">chaîne de caractères</xsl:variable>

Ainsi, pour le même document HTML final, nous aurions pu écrire le template suivant :

<xsl:template match="/">
  <xsl:variable name="couleur">rouge</xsl:variable>
  
  <html>
    <head>
	  <title>Test des variables</title>
	</head>
	<body>
	  <p><xsl:value-of select="$couleur" /></p>
	</body>
  </html>			
</xsl:template>

Pour notre second exemple, nous allons construire un template dont la valeur des variables sera alimentée par une expression XPath. Pour illustrer notre exemple, nous allons exploiter le document XML suivant :

<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="transformation.xsl" ?>
<repertoire>
  <!-- John DOE -->
  <personne sexe="masculin">
    <nom>DOE</nom>
    <prenom>John</prenom>
  </personne>
	
  <!-- Marie POPPINS -->
  <personne sexe="feminin">
    <nom>POPPINS</nom>
    <prenom>Marie</prenom>
  </personne>
	
  <!-- Batte MAN -->
  <personne sexe="masculin">
    <nom>MAN</nom>
    <prenom>Batte</prenom>
  </personne>
</repertoire>

Dans cet exemple, nous allons déclarer 3 variables :

  • La variable sexe qui contiendra le sexe d'une personne.

  • La variable nom qui contiendra le nom d'une personne.

  • La variable prenom qui contiendra le prénom d'une personne.

Le but de notre template est alors d'afficher le sexe, le prénom et le nom de chaque personne contenue dans le document XML :

<xsl:template match="/">	
  <html>
    <head>
	  <title>Test des variables</title>
	</head>
	<body>
	  <xsl:for-each select="repertoire/personne">
	    <xsl:variable name="sexe" select="@sexe" />
		  <xsl:variable name="nom" select="nom" />
		  <xsl:variable name="prenom" select="prenom" />
		    
      <p><xsl:value-of select="$nom"/>&#160;<xsl:value-of select="$prenom"/> : <xsl:value-of select="$sexe"/></p>		    
	  </xsl:for-each>
	</body>
  </html>			
</xsl:template>

Dans ce template, nous parcourons l'ensemble des personnes contenues dans le document XML à l'aide de la fonction<xsl:for-each />, puis nous déclarons 3 variables dont les valeurs sont renseignées à l'aide d'expressions XPath. Grâce à la fonction<xsl:value-of />, il est ensuite très simple d'afficher le contenu de la variable.

La fonction call-template

Maintenant que vous maitrisez les variables, il est grand temps de mettre en pratique vos connaissances ! En effet, dans les exemples que nous avons vu jusqu'à maintenant, l'utilisation des variables n'était pas pertinente, et nous pouvons facilement arriver au même résultat sans les utiliser. La fonction que nous allons voir maintenant va nous permettre d'utiliser les variables dans des cas utiles.

Définition : première partie

La fonction<xsl:call-template />permet d'appeler un autre template au sein d'un template. Il est possible de l'appeler grâce à son nom. Cette fonction accepte donc un attribut "name" qui permet d'identifier le template à appeler.

Jusqu'à maintenant, nous avions renseigné l'attribut "match" de nos templates grâce à une expression XPath. Les templates appelés grâce à la fonction<xsl:call-template />doivent être identifiés par un nom. Il ne convient donc plus de renseigner l'attribut "match", mais l'attribut "name" qui permet d'identifier de manière unique le template.

Voici alors la syntaxe d'un template à appeler :

<xsl:template name="nom_du_template">
    <!-- contenu -->
</xsl:template>

Pour l'appeler, il convient donc d'utiliser la fonction<xsl:call-template />et de renseigner le nom du template à appeler :

<xsl:template match="/">
  <xsl:call-template name="nom_du_template" />
</xsl:template>

Afin d'illustrer ce premier aperçu de la fonction<xsl:call-template />, je vous propose un premier exemple. Dans celui-ci, nous allons écrire un premier template qui capture la racine d'un document XML et qui écrit la structure d'un document HTML. Ce même template appellera un second template grâce à la fonction que nous venons de voir afin que celui-ci peuple le contenu de l'élément<body />de notre document HTML à produire.

Voici les templates à écrire :

<xsl:template match="/">	
  <html>
    <head>
	  <title>Test de la fonction call-template</title>
	</head>
	<body>
	  <xsl:call-template name="body" />
	</body>
  </html>			
</xsl:template>
	
<xsl:template name="body">
  <p>Contenu de la page HTML</p>
</xsl:template>

Comme vous pouvez le constater, notre premier template appelle un second template identifié par le nom "body" grâce à la fonction<xsl:call-template />que nous venons de voir.

Le document HTML produit est bien conforme à nos attentes :

<!DOCTYPE html
  PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
   <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Test de la fonction call-template</title>
   </head>
   <body>
    <p>Contenu de la page HTML</p>
   </body>
</html>

Si l'intérêt de l'exercice est ici limité, ce genre de méthode nous permet surtout de bien hiérarchiser nos documents XSLT en créant un template associé à un rôle bien précis. Dans notre cas, nous avons un premier template dont le rôle est de créer la structure de la page HTML tandis que le second template permet d'en écrire le contenu. La relecture et la modification du document XSLT sont ainsi facilitées.

Définition : deuxième partie

Je vous avais promis que l'étude de la fonction<xsl:call-template />nous permettrait de mettre en application nos connaissances sur les variables, chose que nous n'avons pas encore faite. Il est donc temps de passer aux choses sérieuses ! ;)

A l'appel d'un template, il est possible de lui faire passer des paramètres que nous utiliserons comme des variables dans le template appelé. Ces paramètres sont tout simplement des informations que l'on souhaite transmettre au template appelé. Ainsi, il sera par exemple possible de lui faire passer le nom d'une personne afin de l'afficher. Les paramètres s'utilisent exactement comme les variables à ceci près qu'ils se déclarent grâce à la fonction<xsl:with-param />. Tout comme la fonction<xsl:variable />, elle accepte deux attributs :

  • Name : c'est le nom que l'on souhaite donner à l'attribut, ce nom va nous permettre de l'identifier de manière unique.

  • Select : cet attribut optionnel accepte soit une expression XPath qui permet de sélectionner la valeur que l'on souhaite stocker dans notre variable, soit une chaîne de caractères.

<xsl:with-param name="nom_du_parametre" select="expression XPath|chaîne de caractères" />

Voyons alors comment faire passer les paramètres à un template appelé :

<xsl:call-template name="nom_du_template">
  <xsl:with-param name="parametre_un">valeur 1</xsl:with-param>
  <xsl:with-param name="parametre_deux">valeur 1</xsl:with-param>
</xsl:call-template>

Comme vous pouvez le constater, il convient simplement d'encapsuler les fonctions<xsl:with-param />dans la fonction<xsl:call-template />. Nous devons encapsuler autant de fonctions<xsl:with-param />que nous voulons de paramètres.

Ce n'est pas tout ! Nous devons également déclarer les paramètres au niveau du template appelé. La déclaration des paramètres attendus par un template ne se fait plus avec la fonction<xsl:with-param />, mais la fonction<xsl:param />qui accepte deux attributs :

  • Name : c'est le nom du paramètre que l'on attend.

  • Select : cet attribut optionnel accepte soit une expression XPath, soit une chaîne de caractères et permet de définir une valeur par défaut au paramètre.

<xsl:param name="nom_du_parametre" select="expression XPath|chaîne de caractères" />

Ainsi, si j'appelle un template de la manière suivante :

<xsl:call-template name="nom_du_template">
  <xsl:with-param name="parametre_un">valeur 1</xsl:with-param>
  <xsl:with-param name="parametre_deux">valeur 1</xsl:with-param>
</xsl:call-template>

le template appelé peut bien contenir les 2 paramètres attendus :

<xsl:template name="nom_du_template">
  <xsl:param name="parametre_un" ></xsl:param>
  <xsl:param name="parametre_deux" ></xsl:param>
</xsl:call-template>

Comme pour les variables, pour pouvoir utiliser un paramètre et récupérer la valeur qu'il contient, il convient de précéder son nom par le symbole "$".

Je vous propose de terminer ce chapitre par un exemple. Pour cet exemple, nous allons exploiter le document XML suivant :

<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="transformation.xsl" ?>
<repertoire>
  <!-- John DOE -->
  <personne sexe="masculin">
    <nom>DOE</nom>
    <prenom>John</prenom>
  </personne>
	
  <!-- Marie POPPINS -->
  <personne sexe="feminin">
    <nom>POPPINS</nom>
    <prenom>Marie</prenom>
  </personne>
	
  <!-- Batte MAN -->
  <personne sexe="masculin">
    <nom>MAN</nom>
    <prenom>Batte</prenom>
  </personne>
</repertoire>

Nous allons écrire un document XSLT contenant deux templates :

  • Le premier template capturera la racine du document XML et construira la structure du document HTML à produire. Il bouclera également sur chaque personne du document XML et appellera un second template en lui donnant en paramètre le nom de chaque personne.

  • Le second template accueillera 2 paramètres. Le premier sera le nom de la personne tandis que le deuxième aura pour valeur par défaut la chaîne de caractères "nom de la personne". Le but de ce second template sera d'afficher le nom de la personne.

Voici à quoi ressemble notre document XSLT :

<xsl:template match="/">	
  <html>
    <head>
	  <title>Test de la fonction call-template</title>
	</head>
	<body>
	  <xsl:for-each select="repertoire/personne">
	    <xsl:call-template name="afficherNom">
		  <xsl:with-param name="nomFamille" select="nom" />
		</xsl:call-template>
	  </xsl:for-each>	  
	</body>
  </html>			
</xsl:template>
	
<xsl:template name="afficherNom">
  <xsl:param name="nomFamille" />
  <xsl:param name="constante">nom de la personne</xsl:param>

  <p><xsl:value-of select="$constante"/>:<xsl:value-of select="$nomFamille"/></p>
</xsl:template>

Le document HTML produit est alors le suivant :

<!DOCTYPE html
  PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
   <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Test de la fonction call-template</title>
   </head>
   <body>
    <p>nom de la personne:DOE</p>
    <p>nom de la personne:POPPINS</p>
    <p>nom de la personne:MAN</p>
   </body>
</html>

D'autres fonctions

La fonction element

Définition

La fonction<xsl:element />est une fonction que nous utiliserons principalement pour transformer un document XML en un nouveau document XML. En effet, comme son nom le laisse deviner, cette fonction permet de créer un élément au sens XML, c'est-à-dire une balise XML.

Cette fonction accepte plusieurs attributs. Dans le cadre de ce cours, deux nous intéressent :

  • L'attribut "name", obligatoire, permet de définir le nom de l'élément XML que l'on souhaite créer. Ce nom peut-être une chaîne de caractères ou encore la valeur d'une variable.

  • L'attribut "namespace", facultatif quant à lui, permet de préfixer l'élément à créer d'un espace de noms.

La syntaxe de la fonction<xsl:element />est donc la suivante :

<xsl:element name="nom" namespace="espace_de_nom" />

A noter : pour définir une valeur à l'élément, il convient tout simplement de la placer entre la balise ouvrante et fermante de la fonction :

<xsl:element name="nom" namespace="espace_de_nom">valeur de l'élément </xsl:element>
Exemple

Afin d'illustrer l'utilisation de cette nouvelle fonction, je vous propose de voir immédiatement un exemple. Nous allons donc écrire un template dont le rôle est de créer un élément XML ayant pour nom "couleur" et pour valeur "rouge".

<xsl:template match="/"> 
  <xsl:element name="couleur">rouge</xsl:element>	
</xsl:template>

Le document XML produit est alors le suivant :

<?xml version="1.0" encoding="utf-8"?>
<couleur>rouge</couleur>

La fonction attribute

Définition

La fonction<xsl:attribute />est une fonction grâce à laquelle il est possible de créer des attributs à des éléments XML ou HTML.

Dans le cadre de ce tutoriel, nous allons nous intéresser au seul attribut obligatoire pour cette fonction. Il s'agit de l'attribut "name" qui permet de définir le nom de l'attribut que l'on souhaite créer.

La syntaxe de la fonction<xsl:attribute />est donc la suivante :

<xsl:attribute name="nom" />

Comme pour la fonction<xsl:element />, pour définir la valeur, il convient de la placer entre la balise ouvrante et fermante de la fonction :

<xsl:attribute name="nom">valeur de l'élément </xsl:attribute>
Exemple

Pour illustrer la fonction<xsl:attribute />, je vous propose de compléter notre exemple précédent. Ainsi, nous allons toujours produire un document XML qui grâce à une transformation XSLT contiendra un élément ayant pour nom "couleur" et pour valeur "rouge". La nouveauté est que notre template devra également ajouter l'attribut "primaire" à l'élément "couleur" afin de préciser s'il s'agit d'une couleur primaire ou non.

<xsl:template match="/"> 
  <xsl:element name="couleur">
    <xsl:attribute name="primaire">oui</xsl:attribute>
    rouge
  </xsl:element>	
</xsl:template>

Le document XML produit est alors le suivant :

<?xml version="1.0" encoding="utf-8"?>
<couleur primaire="oui">rouge</couleur>

La fonction comment

Définition

La fonction<xsl:comment />est une fonction qui permet de créer des commentaires dans les documents XML ou HTML à produire. Cette fonction ne prend aucun attribut. Pour définir sa valeur, il suffit simplement de la placer entre la balise ouvrante et fermante de la fonction :

<xsl:comment>mon commentaire</xsl:comment>
Exemple

Cette fonction est relativement simple d'utilisation par rapport à d'autres fonctions que nous avons vu tout au long de ce tutoriel. Cependant, je vous propose tout de même d'illustrer l'utilisation de cette fonction<xsl:comment />par un exemple très simple.

Nous allons donc compléter le template créé précédemment afin d'y ajouter un commentaire ayant pour valeur "ma couleur" :

<xsl:template match="/">
  <xsl:comment>ma couleur</xsl:comment>
  <xsl:element name="couleur">
    <xsl:attribute name="primaire">oui</xsl:attribute>
    rouge
  </xsl:element>
</xsl:template>

Le document XML produit est alors le suivant :

<?xml version="1.0" encoding="utf-8"?>
<!--ma couleur-->
<couleur primaire="oui">rouge</couleur>

La fonction processing-instruction

Définition

La fonction <xsl:processing-instruction />, malgré son nom barbare, permet de créer ce qu'on appelle une instruction de traitement dans le document que l'on souhaite produire. Une instruction de traitement est une de ces fameuses balises XML qui débute par le caractère "?".

C'est notamment ce qu'on utilise dans les documents XML pour référencer un fichier CSS ou une transformation XSLT :

<?xml-stylesheet type="text/xsl" href="transformation.xsl"?>

Cette fonction accepte un seul attribut qui est l'attribut "name" et qui permet de définir le nom de l'instruction. Le reste des éléments contenus dans l'instruction comme par exemple "type" et "href" doit être placé entre la balise ouvrante et fermante de la fonction :

<xsl:processing-instruction name="nom_instruction">reste de l'instruction</xsl:processing-instruction>
Exemple

Afin d'illustrer l'utilisation de cette fonction, je vous propose de continuer à travailler avec le document XML que nous produisons depuis le début de ce chapitre. Ainsi, dans ce document XML, nous allons ajouter une nouvelle référence, un document XSLT fictif portant le nom "transformation.xsl" :

<xsl:template match="/">
  <xsl:processing-instruction name="xml-stylesheet">type="text/xsl" href="transformation.xsl"</xsl:processing-instruction>
  <xsl:comment>ma couleur</xsl:comment>
  <xsl:element name="couleur">
    <xsl:attribute name="primaire">oui</xsl:attribute>
    rouge
  </xsl:element>	
</xsl:template>

Le document XML produit est alors le suivant :

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="transformation.xsl"?>
<!--ma couleur-->
<couleur primaire="oui">rouge</couleur>

La fonction copy-of

Définition

La fonction<xsl:copy-of />, permet de copier tel quel un nœud et ses enfants dans le document que l'on souhaite produire. Cette fonction accepte uniquement l'attribut "select" qui permet de sélectionner ne le nœud à copier en passant par une expression XPath :

<xsl:copy-of select= "expression XPath" />
Exemple

Afin d'illustrer l'utilisation de cette fonction, nous allons transformer le document XML suivant :

<?xml version="1.0" encoding="UTF-8"?> 
<repertoire>
  <personne sexe="masculin">
    <nom>DOE</nom>
	<prenom>John</prenom>
  </personne>
	
  <personne sexe="feminin">
    <nom>POPPINS</nom>
	<prenom>Marie</prenom>
  </personne>

  <personne sexe="masculin">
    <nom>BATTE</nom>
	<prenom>Man</prenom>
  </personne>
</repertoire>

Dans la transformation suivante, l'objectif sera de produire un document XML qui ne contient que les personnes de sexe féminin. Voici le template à utiliser :

<xsl:template match="/">
  <xsl:element name="repertoire">
    <xsl:for-each select="repertoire/personne">
      <xsl:if test="@sexe = 'feminin'">
        <xsl:copy-of select="."/>
      </xsl:if>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

Le document XML produit est alors le suivant :

<?xml version="1.0" encoding="utf-8"?>
<repertoire>
   <personne sexe="feminin">
    <nom>POPPINS</nom>
    <prenom>Marie</prenom>
   </personne>
</repertoire>

Un exemple avec EditiX

Pour conclure ce chapitre, je vous propose de voir comment effectuer une transformation XSLT avec EditiX.

Création du document XML

Commencez par créer dans EditiX un document XML contenant les informations suivantes :

<?xml version="1.0" encoding="UTF-8"?> 
<repertoire>
  <personne sexe="masculin">
    <nom>DOE</nom>
	<prenom>John</prenom>
  </personne>
	
  <personne sexe="feminin">
    <nom>POPPINS</nom>
	<prenom>Marie</prenom>
  </personne>

  <personne sexe="masculin">
    <nom>BATTE</nom>
	<prenom>Man</prenom>
  </personne>
</repertoire>

Création du document XSLT

Pour créer un nouveau document, vous pouvez sélectionner dans la barre de menu File puis New ou encore utiliser le raccourci clavier Ctrl + N.

Dans la liste qui s'affiche, sélectionnez XSL Transformations 1.0 for HTML output, comme indiqué sur la figure suivante :

Image utilisateur
Création d'un document XSLT

Votre document XSLT n'est normalement pas vierge. Voici ce que vous devriez avoir :

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

<!-- New document created with EditiX at Tue Nov 05 22:29:40 CET 2013 -->

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

  <xsl:output method="html" />
	
  <xsl:template match="/">
  <html>
    <body>	
	  <xsl:apply-templates />
	</body>
  </html>
  </xsl:template>

</xsl:stylesheet>

Remplacez le contenu par notre véritable transformation :

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

  <xsl:output 
    method="html"
    encoding="UTF-8"
    doctype-public="-//W3C//DTD HTML 4.01//EN"
    doctype-system="http://www.w3.org/TR/html4/strict.dtd"
    indent="yes" 
  />
  
  <xsl:template match="/">
    <html>
      <head>
        <title>Mon répertoire téléphonique</title>
        <link type="text/css" rel="stylesheet" href="style.css"/>
      </head>
      <body>
         <xsl:for-each select="repertoire/personne">
           <p><xsl:value-of select="nom" /></p>     
         </xsl:for-each>
      </body>
    </html>
  </xsl:template>

</xsl:stylesheet>

Enregistrez ensuite votre document avec le nom transformation.xsl au même endroit que votre document XML.

Vérification du document XSLT

Vous pouvez vérifier que votre transformation n'a pas d'erreur de syntaxe en sélectionnant dans la barre de menu XML puis Check this document ou encore en utilisant le raccourci clavier Ctrl + K.

Vous devriez normalement avoir le message suivant s'afficher :

Image utilisateur
Message indiquant que le document XSLT est bien formé

Appliquer une transformation

Nous allons maintenant voir comment appliquer la transformation que nous venons d'écrire à notre document XML. Pour ce faire, il convient de sélectionner dans la barre de menu XSLT/Query puis Transform a document with this XSLT... ou encore en cliquant sur l'icône suivante :

Image utilisateur

Une fenêtre apparaît alors, nous permettant de choisir :

  • La transformation à appliquer.

  • Le document XML à transformer.

  • Le nom du document qui sera produit à l'issu de la transformation.

  • Le comportement souhaité à la fin de l'opération.

Complétez alors les informations comme dans la capture d'écran ci-dessous :

Image utilisateur
Fenêtre d'exécution d'une transformation XSLT

Lorsque tout est correctement paramétré, cliquez sur le bouton "Ok" pour appliquer la transformation. Une fois celle-ci terminée et en cas de succès, le message suivant doit normalement apparaître à l'écran :

Image utilisateur
Message indiquant que la transformation XSLT a été appliquée

Vous pouvez maintenant vérifier que le document HTML produit contient bien le résultat attendu.
A noter : un aperçu du résultat de la transformation est disponible dans le module "XSLT Preview Result" situé en bas de votre écran lorsque votre document XSLT est ouvert :

Image utilisateur
Résultat de la transformation XSLT

En résumé

  • Il est possible de déclarer des variables dans un document XSLT grâce à la balise<xsl:variable />.

  • Pour utiliser une variable, il suffit de précéder son nom par le symbole "$".

  • Il est possible de faire passer des informations d'un template à un autre sous la forme de paramètres.

Exemple de certificat de réussite
Exemple de certificat de réussite