• 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

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

Le chapitre précédent nous a permis de découvrir la technologie XSLT et notamment la structure générale d'un document. Dans ce nouveau chapitre, nous allons nous attaquer au corps d'un document XSLT.

Le corps d'un document XSLT est composé d'un ensemble de templates. C'est cette notion que nous allons approfondir dans ce chapitre. Nous allons voir, étape par étape, comment écrire un template et ainsi sélectionner et exploiter les informations du document XML à transformer.

Introduction aux templates

Maintenant que vous savez qu'un document XSLT est composé d'un ensemble de templates, je vous propose de rentrer dans le vif du sujet et de découvrir ensemble comment écrire les différents templates qui composeront nos futurs documents XSLT.

Structure d'un template

Un template est défini par la balise<xsl:template />à laquelle plusieurs attributs peuvent être associés. Dans le cadre de ce tutoriel, nous renseignerons systématiquement l'un des 2 attributs suivants :

  • L'attribut match permet de renseigner une expression XPath. Cette expression XPath permet alors de sélectionner les informations du document XML auxquelles le template s'applique.

  • L'attribut name est le nom donné au template, permettant de l'identifier de manière unique. Cet attribut est important puisque nous verrons par la suite qu'il ne soit pas rare qu'un template en appelle un autre.

<xsl:template
  match="expression XPath"
  name="nom du template"
>
    <!-- contenu du template -->
</xsl:template>

Aller plus loin

Pour aller plus loin, sachez qu'il existe d'autres attributs comme par exemple les attributs priority ou mode qui permettent respectivement de renseigner une priorité ou un mode de traitement. Dans le cadre de ce tutoriel, nous ne les exploiterons pas et nous nous contenterons d'utiliser les attributs match et name.

Contenu d'un template

Maintenant que nous avons vu la structure d'un template, il convient d'étudier le cœur d'un template, c'est-à-dire son contenu.

Introduction au contenu d'un template

Le contenu d'un template permet de définir les transformations à appliquer à l'ensemble des données sélectionnées par l'expression XPath qui lui est attachée. Ce contenu peut être de différentes natures. Ainsi, il est par exemple possible de simplement remplacer les informations sélectionnées par du texte, ou d'y appliquer des transformations plus complexes à l'aide de nombreuses fonctions que nous étudierons dans ce tutoriel.

Notre premier template

Afin d'illustrer cette définition, je vous propose de voir ensemble un premier exemple dans lequel nous allons créer un document HTML à partir d'un document XML.

Le document XML
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="transformation.xsl" ?>
<personne>
  <nom>BATTE</nom>
  <prenom>Man</prenom>
</personne>

Comme il est possible de le lire dans ce document XML, à ce dernier est associé le document XSLT transformation.xsl. C'est lui qui contient toutes les instructions qui permettent de transformer les données du document XML en un document HTML.

Le document XSLT

Pour notre exemple, voici le contenu du document transformation.xsl :

<?xml version="1.0" encoding="UTF-8"?>
<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 premier document XSLT</title>
	  </head>
	  <body>
	    <p>Bonjour !</p>
	  </body>
	</html>			
  </xsl:template>
</xsl:stylesheet>

Revenons sur les différents éléments qui composent ce document XSLT. Attardons nous tout d'abord sur la balise<xsl:output />dont le contenu ne doit pas vous être inconnu. Les attributs de cette balise nous permettent d'indiquer que nous souhaitons un document HTML 4 dont le contenu sera indenté et encodé en UTF-8.

Regardons maintenant du côté de notre premier template. Nous pouvons nous apercevoir qu'il possède l'attribut "match", qui sélectionne toutes les données de notre document XML via l'expression XPath"/".

Revenons maintenant sur la réelle nouveauté de ce document XSLT à savoir, le contenu du template. Ici, il s'agit tout simplement de l'écriture d'un document HTML qui, en réalité, n'exploite absolument pas les données sélectionnées dans le document XML. Ainsi, le document produit suite à l'application de ce template sera toujours le même, peu importe les données fournies par le document XML. Ne vous inquiétez pas, nous verrons comment exploiter les données sélectionnées dans la suite du tutoriel. ;)

Le résultat

Le document HTML produit par la transformation du document XML par le document XSLT est donc 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>Mon premier document XSLT</title>
   </head>
   <body>
    <p>Bonjour !</p>
   </body>
</html>

Plusieurs choses importantes sont à noter. Tout d'abord, on retrouve bien les informations que nous avions précisées dans la balise<xsl:output /> dans notre document XSLT à savoir les informations sur le Doctype, les informations sur l'encodage ainsi que l'indentation du document.

Les fonctions

Après avoir créé notre premier template dans le chapitre précédent, je vous propose maintenant de nous attaquer aux différentes fonctions que le XSLT met à notre disposition. Ces fonctions vont nous permettre d'exploiter les données sélectionnées par nos templates afin de procéder à des transformations plus ou moins complexes.

Dans la suite de ce chapitre, le document XML utilisé sera le 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>
    <adresse>
      <numero>7</numero>
      <voie type="impasse">impasse du chemin</voie>
      <codePostal>75015</codePostal>
      <ville>PARIS</ville>
      <pays>FRANCE</pays>
    </adresse>
    <telephones>
      <telephone type="fixe">01 02 03 04 05</telephone>
      <telephone type="portable">06 07 08 09 10</telephone>
    </telephones>
    <emails>
      <email type="personnel">john.doe@wanadoo.fr</email>
      <email type="professionnel">john.doe@societe.com</email>
    </emails>
  </personne>
	
  <!-- Marie POPPINS -->
  <personne sexe="feminin">
    <nom>POPPINS</nom>
    <prenom>Marie</prenom>
    <adresse>
      <numero>28</numero>
      <voie type="avenue">avenue de la république</voie>
      <codePostal>13005</codePostal>
      <ville>MARSEILLE</ville>
      <pays>FRANCE</pays>
    </adresse>
    <telephones>
      <telephone type="professionnel">04 05 06 07 08</telephone>
    </telephones>
    <emails>
      <email type="professionnel">contact@poppins.fr</email>
    </emails>
  </personne>
	
  <!-- Batte MAN -->
  <personne sexe="masculin">
    <nom>MAN</nom>
    <prenom>Batte</prenom>
    <adresse>
      <numero>24</numero>
      <voie type="avenue">impasse des héros</voie>
      <codePostal>11004</codePostal>
      <ville>GOTHAM CITY</ville>
      <pays>USA</pays>
    </adresse>
    <telephones>
      <telephone type="professionnel">01 03 05 07 09</telephone>
    </telephones>
  </personne>
</repertoire>

Afin de gagner en clarté, je ne vais pas réécrire à chaque fois la totalité du document XSLT utilisé. Je me contenterai d'écrire uniquement l'unique template que notre document contiendra. Ainsi, la structure générale du document transformation.xsl est la suivante :

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

</xsl:stylesheet>

La fonction value-of

Syntaxe et explications

La fonction<xsl:value-of />, que l'on peut traduire en français par "valeur de", nous permet d'extraire la valeur d'un élément XML ou la valeur de ses attributs.

Cette fonction possède un attribut select auquel il convient de renseigner une expression XPath permettant alors de sélectionner les informations à extraire :

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

A titre d'exemple, je vous propose d'écrire un template qui va afficher le type du numéro de téléphone et le numéro en lui-même de Marie POPPINS :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction value-of</title>
	</head>
	<body>
	  <p>Type du numéro : <xsl:value-of select="repertoire/personne[nom='POPPINS']/telephones/telephone/@type" /></p>
	  <p>Numéro : <xsl:value-of select="repertoire/personne[nom='POPPINS']/telephones/telephone" /></p>
	</body>
  </html>			
</xsl:template>

Comme vous pouvez le constater, notre template contient 2 fonctions<xsl:value-of />. La première extrait l'attribut "type" de l'unique numéro de téléphone de Marie POPPINS, tandis que la seconde extrait la valeur de l'élément à proprement parler, le tout grâce à des expressions XPath.

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 value-of</title>
   </head>
   <body>
    <p>Type du numéro : professionnel</p>
    <p>Numéro : 04 05 06 07 08</p>
   </body>
</html>

La fonction for-each

Syntaxe et explications

La fonction<xsl:for-each />, que l'on peut traduire en français par "pour chaque" est une fonction qui permet de boucler sur un ensemble d'éléments.

Par exemple, si l'on souhaite appliquer une transformation à l'ensemble des numéros de téléphone d'une personne, nous allons tous les sélectionner à l'aide d'une expression XPath, puis, grâce à la fonction<xsl:for-each />, il sera possible de parcourir l'ensemble des résultats obtenus pour y appliquer une transformation particulière.

Comme pour la fonction<xsl:value-of />, la fonction<xsl:for-each />possède un attribut select auquel il convient de renseigner une expression XPath permettant alors de sélectionner les informations à extraire :

<xsl:for-each select="expression XPath" />
Exemple

Pour illustrer l'utilisation de la fonction<xsl:for-each />, je vous propose d'écrire un template qui va afficher pour chaque adresse e-mail de John DOE son type et son contenu :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction for-each</title>
	</head>
    <body>
	  <xsl:for-each select="repertoire/personne[nom='DOE']/emails/email">
	    <p>Type de l'adresse e-mail : <xsl:value-of select="@type" /></p>
		<p>adresse e-mail : <xsl:value-of select="." /></p>
	  </xsl:for-each>
	</body>
  </html>			
</xsl:template>

Comme vous pouvez le constater, notre template contient une fonction<xsl:for-each/>dont le rôle est de sélectionner l'ensemble des adresses e-mails de John DOE. A l'intérieur de cette fonction, nous sommes alors capable d'exploiter individuellement les différentes adresses grâce à la fonction<xsl:value-of />que nous avons vu précédemment.

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 for-each</title>
   </head>
   <body>
    <p>Type de l'adresse e-mail : personnel</p>
    <p>adresse e-mail : john.doe@wanadoo.fr</p>
    <p>Type de l'adresse e-mail : professionnel</p>
    <p>adresse e-mail : john.doe@societe.com</p>
   </body>
</html>

La fonction sort

Syntaxe et explications

La fonction<xsl:sort />est une fonction qui permet de trier un ensemble d'éléments par ordre croissant ou décroissant.

Puisque l'on souhaite trier un ensemble d'éléments, la fonction<xsl:sort />est généralement utilisée au sein de la fonction<xsl:for-each />que nous venons de voir. Elle possède au moins un attribut select auquel il convient de renseigner une expression XPath permettant alors de sélectionner les informations à trier.

La fonction<xsl:sort />accepte également d'autres attributs qui sont cependant optionnels :

  • Order qui accepte les valeurs ascending (croissant) et descending (décroissant) permet de préciser le sens du tri. Par défaut, c'est un tri croissant qui est effectué.

  • Case-order qui accepte les valeurs upper-first (les majuscules d'abord) et lower-first (les minuscules d'abord) permet de préciser qui des majuscules et des minuscules est prioritaire pour effectuer les tris.

  • Data-type qui accepte les valeurs text (texte) et number (nombre) permet de préciser si les données à trier sont des nombres ou du texte.

  • Lang qui accepte pour valeur le code d'une langue (fr pour la langue française, es pour la langue espagnole, it pour l'italien, etc.) qui permet de préciser la langue des éléments à trier. Cet attribut est notamment utile afin de trier des éléments dont la langue possède quelques caractères spécifiques comme par exemple le norvégien, le suédois, etc.

<xsl:sort select="expression XPath" order="ascending|descending" case-order="upper-first|lower-first" data-type="text|number" lang="fr|es|it|..." />
Exemple

Pour illustrer l'utilisation de la fonction<xsl:sort />, je vous propose d'écrire un template qui va afficher le nom et le prénom des personnes contenues dans notre document XML, par ordre alphabétique :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction sort</title>
	</head>
	<body>
	  <xsl:for-each select="repertoire/personne">
	    <xsl:sort  select="nom" />
		<xsl:sort  select="prenom" />
		<p><xsl:value-of select="nom" />&#160;<xsl:value-of select="prenom" /></p>
	  </xsl:for-each>
	</body>
  </html>			
</xsl:template>

Notre template contient une fonction<xsl:for-each/>permettant de boucler sur toutes les personnes contenues dans notre document XML. Il contient également deux fonctions<xsl:sort />permettant de trier par ordre alphabétique de nom et prénom l'ensemble des personnes.
À noter : le caractère "&#160;" est un caractère qui une fois la transformation effectuée sera simplement remplacé par un espace dans notre document HTML.

Le document HTML produit 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 de la fonction sort</title>
   </head>
   <body>
    <p>DOE&nbsp;John</p>
    <p>MAN&nbsp;Batte</p>
    <p>POPPINS&nbsp;Marie</p>
   </body>
</html>

La fonction if

Syntaxe et explications

La fonction<xsl:if />est une fonction qui permet de conditionner une transformation. Par exemple, grâce à cette fonction, il sera possible de n'appliquer une transformation qu'aux personnes de sexe masculin.

Cette fonction possède un attribut test auquel il convient de renseigner la condition. Cette condition peut être la comparaison d'une chaîne de caractères ou de nombres.

<xsl:if test="test de comparaison" />
Les tests

En XSLT, il existe plusieurs types de tests disponibles. Le tableau suivant les résume et les explique :

Condition

Explication

a = b

Cette condition vérifie que la valeur de l'élément a est égale à la valeur de l'élément b.

not(a = b)

Cette condition vérifie que la valeur de l'élément a n'est pas égale à la valeur de l'élément b.

a &lt; b

Le symbole &lt; (lower than) traduit en réalité le symbole <. La condition est donc en réalité la suivante : a < b. Cette condition vérifie que la valeur de l'élément a est strictement inférieure à la valeur de l'élément b.

a &lt;= b

Le symbole &lt; (lower than) traduit en réalité le symbole <. La condition est donc en réalité la suivante : a <= b. Cette condition vérifie que la valeur de l'élément a est inférieure ou égale à la valeur de l'élément b.

a &gt; b

Le symbole &gt; (greater than) traduit en réalité le symbole >. La condition est donc en réalité la suivante : a > b. Cette condition vérifie que la valeur de l'élément a est strictement supérieure à la valeur de l'élément b.

a &gt;= b

Le symbole &gt; (greater than) traduit en réalité le symbole >. La condition est donc en réalité la suivante : a >= b. Cette condition vérifie que la valeur de l'élément a est supérieure ou égale à la valeur de l'élément b.

Il est également possible d'effectuer plusieurs tests à la fois. Ainsi, nous pouvons :

  • Vérifier qu'un premier test est vrai ET qu'un second l'est également.

  • Vérifier qu'un premier test est vrai OU qu'un second l'est.

Dans un test, pour traduire la notion de ET, on utilise le mot anglais and, tandis que pour traduire la notion de OU, on utilise sa traduction anglaise or.

Voyons quelques exemples afin d'illustrer toutes ces notions. Par exemple, si l'on souhaite vérifier que la valeur d'un élément a est strictement supérieure à un élément b ET un élément c, on écrira :

<xsl:if test="a > b and a > c">
  <!-- contenu de la condition -->
</xsl:if>

Voyons la condition à écrire si l'on souhaite vérifier que la valeur d'un élément a est égale à la valeur d'un élément b OU égale à la valeur d'un élément c :

<xsl:if test="a = b or a = c">
  <!-- contenu de la condition -->
</xsl:if>
Exemple

Pour illustrer l'utilisation de la fonction<xsl:if />, je vous propose d'écrire un template qui va afficher le nom et le prénom des personnes de sexe masculin contenues dans notre document XML :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction if</title>
	</head>
	<body>
	  <xsl:for-each select="repertoire/personne">
	    <xsl:if test="@sexe = 'masculin'">
		  <p><xsl:value-of select="nom" />&#160;<xsl:value-of select="prenom" /></p>
		</xsl:if>			
	  </xsl:for-each>
	</body>
  </html>			
</xsl:template>

Notre template parcourt donc l'ensemble des personnes contenues dans notre document XML grâce à la fonction<xsl:for-each/>. Grâce à la fonction<xsl:if/>, il est possible d'appliquer la suite de la transformation uniquement aux personnes de sexe masculin.

Le document HTML produit 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 de la fonction if</title>
   </head>
   <body>
    <p>DOE&nbsp;John</p>
    <p>MAN&nbsp;Batte</p>
   </body>
</html>

La fonction choose

Syntaxe et explications

La fonction<xsl:choose />, tout comme la fonction<xsl:if />, permet de conditionner des transformations. En réalité, la fonction<xsl:choose />ne s'utilise pas toute seule. En effet, elle permet plusieurs conditions. Ainsi, dans le cas où la première condition n'est pas remplie, la seconde va être testée, puis la troisième, etc. Dans le cas où aucune condition n'est remplie, un cas par défaut peut être prévu.

Les conditions inclues dans la fonction<xsl:choose />s'expriment grâce à la fonction<xsl:when />. Le cas par défaut s'exprime quant à lui grâce à la fonction<xsl:otherwise />.

La fonction<xsl:when />possède un attribut test auquel il convient de renseigner une condition.

<xsl:choose>
  <xsl:when test="test de comparaison">
    <!-- suite de la transformation -->
  </xsl:when>
  <xsl:when test="test de comparaison">
    <!-- suite de la transformation -->
  </xsl:when>
  <xsl:otherwise>
    <!-- suite de la transformation -->
  </xsl:otherwise>
</xsl:choose>

Le nombre de fonction<xsl:when />varie en fonction du nombre de conditions que vous souhaitez tester.

Exemple

Pour illustrer l'utilisation de la fonction<xsl:choose />, je vous propose d'écrire un template qui,  suivant le nom des personnes contenues dans le document XML, affichera une phrase personnalisée. Ainsi, pour John DOE, la phrase à afficher sera "Bonjour John !", pour Marie POPPINS, la phrase à afficher sera "Quel beau sac !". Dans tous les autres cas, la phrase à afficher sera "Qui êtes-vous ?".

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction sort</title>
	</head>
	<body>
	  <xsl:for-each select="repertoire/personne">
	    <xsl:choose>
		  <xsl:when test="nom = 'DOE'">
		    <p>Bonjour John !</p>
		  </xsl:when>
		  <xsl:when test="nom = 'POPPINS'">
		    <p>Quel beau sac !</p>
		  </xsl:when>
		  <xsl:otherwise>
		    <p>Qui êtes-vous ?</p>
		  </xsl:otherwise>
		</xsl:choose>
	  </xsl:for-each>
	</body>
  </html>			
</xsl:template>

Puisque les personnes de notre document XML seront traitées dans leur ordre d'apparition de notre document XML, les phrases seront affichées dans cet ordre dans le document HTML produit :

  • Bonjour John !

  • Quel beau sac !

  • Qui êtes-vous ?

C'est effectivement le cas lorsqu'on regarde le document HTML produit :

<!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 sort</title>
   </head>
   <body>
    <p>Bonjour John !</p>
    <p>Quel beau sac !</p>
    <p>Qui &ecirc;tes-vous ?</p>
   </body>
</html>

La fonction apply-templates

Syntaxe et explications

La fonction<xsl:apply-templates /> permet de continuer la transformation des éléments enfants d'un template.

Dans le cadre de ce tutoriel, nous allons uniquement considérer l'attribut select de la fonction<xsl:apply-templates />qu'il convient de renseigner à l'aide d'une expression XPath.

<xsl:apply-templates select="expression XPath" />
Exemple

Pour illustrer l'utilisation de la fonction<xsl:apply-templates />, je vous propose de décortiquer ensemble le template.

Tout d'abord, considérons un document XML un peu plus simple que celui que nous utilisions jusqu'à maintenant :

<?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>

Considérons alors les templates suivants :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction apply-templates</title>
	</head>
	<body>
	  <xsl:apply-templates select="repertoire/personne[nom='POPPINS']" />
	</body>
  </html>			
</xsl:template>
	
<xsl:template match="nom">
  <p><xsl:value-of select="." /></p>
</xsl:template>
	
<xsl:template match="prenom">
  <p><xsl:value-of select="." /></p>
</xsl:template>

A l'exécution de la transformation XSLT, le premier template à être appelé est le template dont l'expression XPath capture la racine de notre document XML. Dans ce template, la ligne<xsl:apply-templates select="repertoire/personne[nom='POPPINS']" />permet d'indiquer que l'on souhaite continuer la transformation uniquement avec l'élément<personne />correspondant à Marie POPPINS ainsi que ses fils à savoir les éléments<nom />et<prenom />. L'élément<nom />va donc être transformé grâce au second template écrit dans notre document XSLT puisque son expression XPath le capture. Finalement, en suivant la même logique, l'élément<prenom />va, quant à lui, être transformé grâce au dernier template de notre document XSLT.

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 sort</title>
   </head>
   <body>        
    <p>POPPINS</p>        
    <p>Marie</p>      
   </body>
</html>

Afin de bien comprendre le mécanisme, je vous propose maintenant de jeter un coup d’œil aux templates suivant :

<xsl:template match="/">
  <html>
    <head>
	  <title>Test de la fonction apply-templates</title>
	</head>
	<body>
	  <xsl:apply-templates select="repertoire/personne[nom='POPPINS']/nom" />
	</body>
  </html>			
</xsl:template>
	
<xsl:template match="nom">
  <p><xsl:value-of select="." /></p>
</xsl:template>
	
<xsl:template match="prenom">
  <p><xsl:value-of select="." /></p>
</xsl:template>

Comme pour notre premier exemple, à l'exécution de la transformation XSLT, le premier template à être appelé est le template dont l'expression XPath capture la racine de notre document XML. Dans ce template, la ligne<xsl:apply-templates select="repertoire/personne[nom='POPPINS']/nom" />permet d'indiquer que l'on souhaite continuer la transformation uniquement avec l’élément<nom />de la<personne />correspondant à Marie POPPINS. L'élément<nom />va donc être transformé grâce au second template de notre document XSLT. Le dernier template ne sera quant à lui jamais appelé.

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 sort</title>
   </head>
   <body>
    <p>POPPINS</p>
   </body>
</html>

En résumé

  • Les templates possèdent systématiquement l'un des 2 attributs : match ou name.

  • Les templates se construisent à l'aide de nombreuses fonctions.

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