SELFHTML: XML/DTD / Représentation de données XML / Éléments XSLT

	Éléments XSLT
	Remarques sur les éléments XSLT xsl:apply-imports (appliquer des feuilles de style importées) xsl:apply-templates (appliquer les modèles subordonnés) xsl:attribute (créer un attribut dans l'arbre de transformation) xsl:attribute-set (créer plusieurs attributs dans l'arbre de transformation) xsl:call-template (appeler un modèle) xsl:choose (faire un choix) xsl:comment (mettre un commentaire) xsl:copy (copier un élément dans l'arbre de transformation) xsl:copy-of (copier un ensemble de nœuds dans l'arbre de transformation) xsl:decimal-format (format décimal) xsl:element (créer un élément) xsl:fallback (instruction d'exécution en alternative) xsl:for-each (répéter pour chacun des éléments d'une quantité) xsl:if (condition si) xsl:import (importer des feuilles de style) xsl:key (clé pour le choix d'éléments) xsl:message (sortir un message lors de la transformation) xsl:namespace-alias (transformer une feuille de style en une autre feuille de style) xsl:number (numérotation continue) xsl:otherwise (instruction autrement) xsl:output (contrôler la création de l'arbre de transformation) xsl:param (définir un paramètre) xsl:preserve-space (conserver les espaces) xsl:processing-instruction (générer un code de feuilles de style) xsl:sort (trier les éléments d'après leur contenu) xsl:strip-space (contrôler le traitement des espaces) xsl:stylesheet (élément racine de la feuille de style) xsl:template (définir un modèle pour l'arbre de transformation) xsl:text (sortir un contenu en caractères) xsl:transform (élément racine de la feuille de style) xsl:value-of (sortir la valeur) xsl:variable (définir une variable) xsl:when (condition à l'intérieur d'un choix) xsl:with-param (affecter une valeur à un paramètre)

Remarques sur les éléments XSLT

L'élément xsl:stylesheet représente l'introduction logique d'un fichier XSL. Le plus important de ses éléments est l'élément xsl:template à l'aide duquel l'arbre de données XML est transcrit dans un arbre de transformation d'un autre langage conforme à XML (par exemple aussi HTML).

Lors de la description des éléments, il est souvent question de nœuds et de types de nœuds. Ces termes trouvent un début d'explication dans la partie sur les Nœuds et jeux de nœuds dans l'arborescence . Des explications plus approfondies à ce sujet se trouvent dans la partie sur la syntaxe XPath. Car XPath représente un langage complémentaire ou d'aide dans une feuille de style XSLT pour entre autres adresser précisément les parties constitutives d'un document XML. XPath a une spécification distincte comme XSLT.

Ne perdez pas de vue, en ce qui concerne l'Explorer Internet les Remarques sur les exemples.

xsl:apply-imports (appliquer des feuilles de style importées)

Applique à l'intérieur d'un modèle défini avec xsl:template des modèles externes définis qui sont importés avec xsl:import.

N'attend aucun attribut.

Ne peut être placé que dans xsl:template.

Fichier d'exemple `apply_imports.xml`:

Exemple d'affichage: aperçu (fichier de résultat apply_imports.htm)
Exemple d'affichage: aperçu (fichier apply_imports.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="apply_imports1.xsl" ?>
<test>
<image>pingouin.gif</image>
<texte>Le pingouin est la marque distinctive de Linux</texte>
</test>

Fichier d'exemple `apply_imports1.xsl`:

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

<xsl:import href="apply_imports2.xsl" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:apply-imports/>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Fichier d'exemple `apply_imports2.xsl`:

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

<xsl:template match="image">
<img><xsl:attribute name="src"><xsl:value-of select="." /></xsl:attribute></img>
</xsl:template>

<xsl:template match="texte">
<p><xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans le document XML apply_imports.xml la feuille de style apply_imports1.xsl est incorporée. Là et à l'aide de <xsl:import href="apply_imports2.xsl" /> une deuxième feuille de style est incorporée, à savoir apply_imports2.xsl. Dans la deuxième feuille de style, figurent des définitions pour la transcription HTML des éléments image et texte. Les définitions correspondantes sont appliquées dans la première feuille de style à l'endroit où <xsl:apply-imports/> est noté.

xsl:apply-templates (appliquer les modèles subordonnés)

Applique à l'intérieur d'un modèle défini avec xsl:template d'autres modèles qui sont le cas échéant définis avec xsl:template. De cette manière, les dépendances et l'ordre lors de l'emploi de modèles peuvent être contrôlés.

a les attributs suivants:

`select=`	(facultatif) choisit un modèle qui doit être appliqué. Le jeu de nœuds désiré est mentionné ou bien un chemin d'après la syntaxe XPath. Quand une définition `xsl:template` existe pour cet élément, elle est appliquée. Si l'attribut `select` manque, toutes les définitions `xsl:template` de l'échelon immédiatement inférieur sont appliquées.
`mode=`	(facultatif) Ne choisit le modèle mentionné avec `select=` que lorsqu'il a le mode mentionné. Pour cela il faut que lors de la définition de `xsl:template` un nom qui concorde ait été attribué pour le mode avec `mode=`.

Peut être placé à l'intérieur de xsl:template.

Fichier d'exemple `apply_templates.xml`:

Exemple d'affichage: aperçu (fichier de résultat apply_templates.htm)
Exemple d'affichage: aperçu (fichier apply_templates.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="apply_templates.xsl" ?>
<test>
<texte>
Ce que tu peux obtenir le <moment>lundi</moment> ne le repousse pas au <moment>mardi</moment>.
</texte>
</test>

Fichier d'exemple `apply_templates.xsl`:

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

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

<xsl:template match="texte">
 <p style="font-family:Tahoma; font-size:14pt">
 <xsl:apply-templates />
 </p>
</xsl:template>

<xsl:template match="moment">
 <i style="color:red">
  <xsl:value-of select="." />
 </i>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans l'exemple de feuilles de style, l'instruction <xsl:apply-templates /> (sans attribut) est placée deux fois. La première fois, elle est notée dans la définition de modèle de la racine du document. Là l'instruction figure dans le passage visible du code HTML à créer. à savoir entre <body> et </body>. Étant donné qu'aucun attribut select n'est mentionné, elle a pour effet qu'à l'endroit correspondant du code HTML, les modèles pour l'échelon pour les échelons immédiatement inférieurs sont appliqués. Dans la structure XML de l'exemple ce sont les éléments du type texte. Pour ces éléments, un modèle est défini avec <xsl:template match="texte">. Les éléments de ce type seront en HTML, inclus dans un paragraphe <p>...</p>qui est formaté avec les CSS. Pour le contenu du paragraphe l'avis s'applique pourtant une nouvelle fois: faire attention aux modèles subordonnés! C'est pourquoi l'instruction <xsl:apply-templates /> est notée à nouveau à l'intérieur du paragraphe de texte. Comme élément subordonné de texte dans l'exemple, l'élément moment peut être placé. Pour cet élément également un modèle a été défini avec <xsl:template match="moment">. Du texte placé dans ces éléments sera, en HTML, représenté en rouge et en italique.
��Etant donné qu'à l'intérieur de l'élément moment il n'y a plus d'autres modèles subordonnés à prendre en considération, il ne faut plus considérer que le que le contenu respectif de l'élément. C'est ce qui est réalisé grâce à l'instruction <xsl:value-of select="." /> (voir aussi xsl:value-of).

xsl:attribute (créer un attribut dans l'arbre de transformation)

Peut poser un attribut dans l'arbre de transformation et lui affecter une valeur, donc par exemple dans l'élément HTML div poser l'attribut align et lui affecter la valeur center.

a les attributs suivants:

`name=`	(obligatoire) Mentionne le nom de l'attribut par exemple `align`.
`namespace=`	(facultatif) mentionne l'URI de l'espace de nommage dont provient l'attribut.

Peut être placé à l'intérieur de xsl:template ou bien à l'intérieur de xsl:attribute-set.

Fichier d'exemple `attributes.xml`:

Exemple d'affichage: aperçu (fichier de résultat attributs.htm)
Exemple d'affichage: aperçu (fichier attributs.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="attributs.xsl" ?>
<test>
<texte  alignement="gauche">
Ceci est du texte align� � gauche
</texte>
<texte alignement="centre">
Ceci est du texte centr�
</texte>
<texte alignement="droite">
Ceci est du texte align� � droite
</texte>
</test>

Fichier d'exemple `attributs.xsl`:

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

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

<xsl:template match="texte">
 <p>
 <xsl:choose>
  <xsl:when test="@alignement='centre'">
   <xsl:attribute name="align">center</xsl:attribute>
  </xsl:when>
  <xsl:when test="@alignement='droite'">
   <xsl:attribute name="align">right</xsl:attribute>
  </xsl:when>
  <xsl:otherwise>
   <xsl:attribute name="align">left</xsl:attribute>
  </xsl:otherwise>
 </xsl:choose>
 <xsl:value-of select="." />
 </p>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans l'exemple, il y a un élément XML texte avec l'attribut alignement, qui peut prendre les valeurs gauche, droite et centre (d'après la DTD non mentionnés dans l'exemple). Dans les données XML trois élément du type texte sont notés, à chaque fois avec une valeur différente pour alignement. Dans la feuille de style de l'exemple, un modèle est défini avec <xsl:template match="texte"> pour l'élément texte. Le modèle a pour effet que les éléments du type texte seront transcrits en éléments HTML du type p. En le faisant, il faut pourtant également prendre en compte l'alignement du texte. Pour permettre de décider si, dans l'élément p, l'attribut align doit recevoir la valeur center, right ou left, il est recherché par des instructions xsl:choose, xsl:when et xsl:otherwise si l'élément à transcrire texte des données XML, a pour l'attribut alignement la valeur centre, droite ou gauche. Sous le module de requête le contenu de l'élément XML texte est finalement transcrit dans le contenu de l'élément HTML p grâce à l'instruction <xsl:value-of select="." />.

xsl:attribute-set (créer plusieurs attributs dans l'arbre de transformation)

définit un ou plusieurs attributs pour l'arbre de transformation et cela séparément. Ceci est particulièrement indiqué pour définir comme blocs de texte des chaînes d'attributs utilisées fréquemment comme border="0" cellpadding="0" cellspacing="0", ou bien pour tenir à disposition des caractéristiques d'éléments en alternative par différents blocs de texte d'attributs.

a les attributs suivants:

`name=`	(obligatoire) affecte un nom pour le jeu d'attributs. Sous ce nom, le jeu d'attributs peut ensuite être utilisé.
`use-attribute-sets=`	(facultatif) incorpore d'autres jeux d'attributs dans le jeu d'attributs actuel. Un ou plusieurs noms d'autres jeux d'attributs sont à mentionner. Plusieurs noms sont séparés par des espaces.

Peut être placé à l'intérieur de xsl:stylesheet et doit être noté à l'extérieur de xsl:template. Peut être employé à l'intérieur d'un modèle par xsl:element ou xsl:copy, par leur attribut use-attribute-sets.

Fichier d'exemple `attribute_set.xml`:

Exemple d'affichage: aperçu (fichier de résultat attribute_set.htm)
Exemple d'affichage: aperçu (fichier attribute_set.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="attribute_set.xsl" ?>
<test>
 <element>
  <terme>
   HTML
  </terme>
  <definition>
   abr�viation pour 'How To Make Love'
  </definition>
 </element>
</test>

Fichier d'exemple `attribute_set.xsl`:

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

<xsl:attribute-set name="visible">
  <xsl:attribute name="border">1</xsl:attribute>
  <xsl:attribute name="cellpadding">3</xsl:attribute>
  <xsl:attribute name="cellspacing">1</xsl:attribute>
</xsl:attribute-set>

<xsl:attribute-set name="invisible">
  <xsl:attribute name="border">0</xsl:attribute>
  <xsl:attribute name="cellpadding">3</xsl:attribute>
  <xsl:attribute name="cellspacing">1</xsl:attribute>
</xsl:attribute-set>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:element name="table" use-attribute-sets="visible">
 <xsl:for-each select="test/element">
 <tr>
  <td valign="top"><b><xsl:value-of select="terme" /></b></td>
  <td valign="top"><xsl:value-of select="definition" /></td>
 </tr>
 </xsl:for-each>
 </xsl:element>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Explication:

L'exemple définit un glossaire. Les données contiennent un élément du glossaire. Dans la feuille de style de l'exemple le glossaire est transcrit en un tableau HTML. Au début de l'extrait d'exemple et en dehors des définitions de modèles, deux jeux d'attributs sont définis avec l'instruction attribute-set, l'un est nommé visible, et l'autre est nommé invisible. Entre le repère d'ouverture <xsl:attribute-set> et son pendant </xsl:attribute-set> des attributs sont définis à l'aide de xsl:attribute; ils pourront être employés plus tard dans les définitions de modèles. Dans l'exemple il s'agit d'attributs qui doivent trouver une utilisation plus tard dans l'élément table. Les deux jeux d'attributs définissent les attributs de telle façon qu'ils rendent possible pour l'un, la définition d'un tableau avec quadrillage et pour l'autre d'un tableau sans quadrillage.
À l'intérieur de la définition de modèle dans laquelle le tableau est créé, l'élément table est créé avec l'instruction <xsl:element name="table" use-attribute-sets="visible">, cet élément aura les attributs qui ont été définis dans le jeu d'attributs nommé visible.

xsl:call-template (appeler un modèle)

Appelle un autre modèle par son nom. Peut également renvoyer des valeurs de paramètres au modèle appelé.

a les attributs suivants

name= (obligatoire) le nom du modèle à appeler qui doit être défini avec <xsl:template name="..." [...]>.

Peut être placé à l'intérieur de xsl:template. peut être noté sans contenu ou bien avec contenu et repère de fermeture. Sont permis comme contenu des éléments du type xsl:with-param.

Fichier d'exemple `call_template.xml`:

Exemple d'affichage: aperçu (fichier de résultat call_template.htm)
Exemple d'affichage: aperçu (fichier call_template.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="call_template.xsl" ?>
<test>
<contact mail="est@aminet.net">Estelle Aminet</contact>
</test>

Fichier d'exemple `call_template.xsl`:

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

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

<xsl:template name="etiquette">
 <xsl:text>, Courriel: </xsl:text>
</xsl:template>

<xsl:template match="contact">
 <div>
 <xsl:value-of select="." />
 <xsl:call-template name="etiquette" />
 <xsl:value-of select="@mail" />
 </div>
</xsl:template>

</xsl:stylesheet>

Explication:

L'exemple XML contient des données de contact pour lesquelles sont notées dans l'élément contact le nom comme contenu; cet élément reçoit comme attribut l'affectation de l'adresse électronique correspondante.
Dans la feuille de style de l'exemple, un modèle est défini et nommé avec <xsl:template name="etiquette">. Dans ce modèle un texte statique a été défini avec xsl:text. À l'intérieur d'un autre modèle défini avec <xsl:template match="contact"> est noté un appel au modèle nommé etiquette et cela grâce à l'instruction <xsl:call-template name="etiquette" />. Dans l'exemple est ainsi créée, à partir des données XML <contact mail="est@aminet.net">Estelle Aminet</contact>, la sortie <div>Estelle Aminet, Courriel: est@aminet.net</div>.

xsl:choose (faire un choix)

Forme le cadre d'une série de requêtes exécutées avec xsl:when et xsl:otherwise. La série peut être constituée du nombre souhaité de requêtes xsl:when et d'une instruction finale xsl:otherwise. La requête qui la première, répond à la condition sera choisie.

n'a pas d'attributs.

Peut être placé à l'intérieur de xsl:template.

Fichier d'exemple `choose.xml`:

Exemple d'affichage: aperçu (fichier de résultat choose.htm)
Exemple d'affichage: aperçu (fichier choose.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="choose.xsl" ?>
<test>
<nombre>69</nombre>
<nombre>12345</nombre>
<nombre>743</nombre>
<nombre>915743</nombre>
</test>

Fichier d'exemple `choose.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <h3>Les nombres sont les suivants:</h3>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="nombre">
<div>
<xsl:value-of select="." />
<xsl:variable name="valeur" select="." />
 <xsl:choose>
  <xsl:when test="$valeur &lt; 10000">
   <xsl:text> (un petit nombre)</xsl:text>
  </xsl:when>
  <xsl:otherwise>
   <xsl:text> (grand nombre)</xsl:text>
  </xsl:otherwise>
 </xsl:choose>
</div>
</xsl:template>

</xsl:stylesheet>

Explication:

Une série de nombres sont notées dans les données XML de l'exemple et cela à chaque fois dans un élément nommé nombre. Dans la feuille de style de l'exemple le modèle est défini avec <xsl:template match="nombre">; il contrôlera la sortie HTML des nombres. La valeur du nombre est sortie avec <xsl:value-of select="." /> (voir également xsl:value-of). Enfin une variable nommée valeur est définie, qui repère la valeur donc le contenu placé entre <nombre> et </nombre>, (voir également xsl:variable). Une série de requêtes est ainsi introduite avec <xsl:choose> . Elle contient une requête xsl:when et une instruction xsl:otherwise. La requête xsl:when demande si la valeur de la variable valeur est plus petite que 10000. Si oui, le texte (un petit nombre) sera sorti à la suite du nombre déjà sorti, dans le cas contraire, ce sera le texte (un grand nombre). Pour la sortie de texte est utilisé xsl:text.

xsl:comment (mettre un commentaire)

Inclut les sorties dans l'arbre de transformation dans des commentaires conformes à XML (également à HTML), de façon à ce que leur contenu ne soit pas sorti.

n'a pas d'attributs.

Peut être placé à l'intérieur de xsl:template.

Exemple d'un extrait d'une feuille de style:

<xsl:template match="/">
 <html>
 <head>
 <script language="JavaScript" type="text/javascript">
 <xsl:comment>
   alert("hello monde");
 </xsl:comment>
 </script>
 </head>
 <body>
 hello monde
 </body>
 </html>
</xsl:template>

Explication:

Dans la feuille de style de l'exemple, un passage JavaScript est noté entre autres lors de la sortie HTML. Le contenu d'un tel passage doit être commenté pour le rendre inaccessible aux navigateurs ne supportant pas JavaScript. Dans l'exemple cela est réalisé à l'aide de l'instruction xsl:comment.

xsl:copy (copier un élément dans l'arbre de transformation)

Copie un nœud actuel dans l'arbre de transformation à l'endroit où est notée l'instruction. Cela est judicieux par exemple quand les données XML contiennent des éléments pour lesquels un élément du même nom existe dans le langage de destination. Les repères d'élément et le contenu PCDATA sont copiés, mais pas les attributs, ni les éléments-enfants (voir également à ce sujet xsl:copy-of).

a les attributs suivants

use-attribute-sets= (facultatif) insérer dans la copie les attributs définis avec xsl:attribute-set.

Peut être placé à l'intérieur de xsl:template. Peut avoir comme contenu tout ce qui est permis à l'intérieur de xsl:template.

Fichier d'exemple `copy.xml`:

Exemple d'affichage: aperçu (fichier de résultat copy.htm)
Exemple d'affichage: aperçu (fichier copy.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="copy.xsl" ?>
<test>
<p>Si nous estimons meilleurs, nous ne le devenons pas pour autant</p>
<p>On ne peut poser de pont qu'entre des rives s�par�es l'une de l'autre</p>
</test>

Fichier d'exemple `copy.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <h1>Aphorismes</h1>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="p">
<xsl:copy><xsl:value-of select="." /></xsl:copy>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple sont composés d'aphorismes qui sont chacun inclus dans un élément XML nommé p. Dans la feuille de style de l'exemple, il a été fixé pour la définition du modèle pour les éléments du type p avec l'instruction <xsl:copy><xsl:value-of select="." /></xsl:copy> qu'ils soient tout simplement copiés dans l'arbre de transformation HTML. Cela se justifie étant donné que l'élément p signifie quelque chose en HTML et qu'il est formaté en conséquence par le navigateur. De cette manière, on obtient pour ce cas le même effet qui serait obtenu avec la définition de modèle suivante:
<xsl:template match="p"> <p><xsl:value-of select="." /></p> </xsl:template>

xsl:copy-of (copier un ensemble de nœuds dans l'arbre de transformation)

Copie dans l'arbre de transformation un nœud actuel et tout le jeu de nœuds qui en dépend, à l'endroit où l'instruction est notée. C'est judicieux par exemple pour répéter à plusieurs endroits le contenu s'un élément qui n'est noté qu'une fois dans les données.

a les attributs suivants

select= (obligatoire) choisir ce qui doit être copié. Cela peut être un jeu de nœuds ou un chemin d'après la syntaxe XPath ou encore une variable.

Peut être placé à l'intérieur de xsl:template. Peut avoir comme contenu tout ce qui est permis à l'intérieur de xsl:template.

Fichier d'exemple `copy_of.xml`:

Exemple d'affichage: aperçu (fichier de résultat copy_of.htm)
Exemple d'affichage: aperçu (fichier copy_of.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="copy_of.xsl" ?>
<test>
<titre>T�l�phone</titre>
<telephone><nom>Alexandre</nom><numero>0442 - 117273</numero></telephone>
<telephone><nom>Marie</nom><numero>0320 - 558458</numero></telephone>
</test>

Fichier d'exemple `copy_of.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1"><xsl:apply-templates /></table>
 </body>
 </html>
</xsl:template>

<xsl:template match="titre">
<tr><th colspan="3"><xsl:value-of select="." /></th></tr>
</xsl:template>

<xsl:template match="telephone">
<tr>
<td><xsl:copy-of select="../titre" /></td>
<xsl:apply-templates />
</tr>
</xsl:template>

<xsl:template match="nom">
<td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="numero">
<td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

Explication:

L'exemple définit une liste de numéros de téléphone, constituée de noms et de numéros de téléphone avec un titre qui est noté dans l'élément titre. Lors de la création de l'arbre de transformation dans la feuille de style de l'exemple, un tableau HTML à trois colonnes est cependant créé à partir de la liste de téléphone. Dans la première colonne figure à chaque fois le mot Téléphone. C'est le résultat de cette instruction qui grâce à <td><xsl:copy-of select="../titre" /></td> répète le titre, qui à vrai dire n'est placé qu'une fois, à chaque fois qu'est rencontré l'élément telephone. L'adressage de l'élément titre a lieu pour ce faire d'après l' adressage XPath avec mention de chemin relative en partant de l'élément telephone.

xsl:decimal-format (format décimal)

Définit un schéma d'après lequel les nombres sont sortis dans l'arbre de transformation. Ce schéma peut être appliqué dans la fonction format-number().

a les attributs suivants

`decimal-separator=`	(facultatif) Signe qui figure entre le nombre entier et les "chiffres après la virgule" pour séparer les deux groupes. En Français, c'est en principe une virgule, en Anglais un point. Le réglage par défaut est le point (`.`).
`digit=`	(facultatif) Signe placé comme "joker" pour un chiffre inconnu. Normalement c'est le signe dièse `#` (réglage par défaut).
`grouping-separator=`	(facultatif) Signe qui sépare un groupe de signes par exemple comme "signe des milliers". En Français, c'est en principe le point, en Anglais c'est la virgule. Le réglage par défaut est la virgule (`,`).
`infinity=`	(facultatif) Signe ou chaîne de caractères qui représente la valeur pour "infini" par exemple pour des valeurs périodiques après la virgule. Le réglage par défaut est `Infinity`.
`minus-sign=`	(facultatif) Signe qui précède une valeur négative. Normalement c'est le signe moins `-` (réglage par défaut).
`name=`	(facultatif) Nom du schéma défini. Sous ce nom, le schéma peut être utilisé dans la fonction `format-number`. Si aucun nom n'est donné, les définitions s'appliquent globalement.
`NaN=`	(facultatif) Chaîne de caractères qui exprime qu'une valeur n'est pas un nombre valide. Le réglage par défaut est `NaN` (not a number).
`pattern-separator=`	(facultatif) Signe qui figure entre la représentation de format d'un nombre positif et la représentation de format d'un nombre négatif. Le réglage par défaut est le point virgule (`;`).
`per-mille=`	(facultatif) Signe qui désigne des valeurs pour-mille. Le réglage par défaut est `%O`.
`percent=`	(facultatif) Signe qui désigne des valeurs pour cent. Le réglage par défaut est le signe de pourcentage `%`.
`zero-digit=`	(facultatif) Signe pour la représentation de zéros précédant un chiffre. Le réglage par défaut est le zéro `0`.

Peut être placé à l'intérieur de xsl:stylesheet et doit être noté à l'extérieur de xsl:template.

Fichier d'exemple `decimal_format.xml`:

Exemple d'affichage: aperçu (fichier de résultat decimal_format.htm)
Exemple d'affichage: aperçu (fichier decimal_format.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="decimal_format.xsl" ?>
<test>
<valeur>1230348345</valeur>
<valeur>17235807</valeur>
<valeur>12345</valeur>
</test>

Fichier d'exemple `decimal_format.xsl`:

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

<xsl:decimal-format name="fr" decimal-separator="," grouping-separator="."/>

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

<xsl:template match="valeur">
<div><xsl:value-of select="format-number(.,'#.##0,0','de')"/></div>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML, différentes valeurs sont simplement notées et cela dans un élément nommé valeur. Dans la feuille de style de l'exemple, un schéma pour le formatage de nombres dans l'arbre de transformation est défini avec xsl:decimal-format. Le schéma contient le nom fr et détermine la virgule comme séparateur pour les nombres entiers et les positions décimales ainsi que le point pour séparer les groupes de milliers. Un modèle est défini pour l'élément du type valeur avec <xsl:template match="valeur">. Chaque valeur est sortie dans un élément HTML div. Avec l'instruction <xsl:value-of select="format-number(.,'#.##0,0','fr')"/> on se réfère au contenu de valeur, et cela par l'appel de la fonction format-number. Celle-ci reçoit entre parenthèses comme premier paramètre le point ., ce qui figure pour l'élément actuel. Le deuxième paramètre est une chaîne de format et le troisième le nom du schéma qui avait été défini auparavant avec xsl:decimal-format.

xsl:element (créer un élément)

Crée un élément dans un arbre de transformation. Il est à vrai dire courant de noter directement des éléments dans l'arbre de transformation. Par exemple, lors de l'application de différents Attribut-Sets il peut être judicieux de ne pas noter les éléments directement dans l'arbre de transformation mais de les générer à l'aide de xsl:element. Un autre cas d'application est quand un arbre de transformation doit être créé à l'aide de XSL et que le langage de destination est lui-même XSL.

a les attributs suivants

`name=`	(obligatoire) Nom de l'élément à générer par exemple `table` pour l'élément HTML du même nom
`namespace=`	(facultatif) Espace de nommage auquel l'élément appartient.
`use-attribute-sets=`	(facultatif) jeux d'attributs définis devant être placés dans le repère d'ouverture de l'élément à créer.

Peut être placé xsl:template .

Fichier d'exemple `element.xml`:

Exemple d'affichage: aperçu (fichier de résultat element.htm)
Exemple d'affichage: aperçu (fichier element.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="element.xsl" ?>
<test>
<produit><nom>Fauteuil � bascule</nom><prix>99,-</prix></produit>
<produit><nom>Machine � caf�</nom><prix>49,95</prix></produit>
<produit><nom>Tournevis</nom><prix>4,95</prix></produit>
<produit><nom>Coussin</nom><prix>29,95</prix></produit>
</test>

Fichier d'exemple `element.xsl`:

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

<xsl:attribute-set name="gris">
  <xsl:attribute name="bgcolor">#E0E0E0</xsl:attribute>
</xsl:attribute-set>
<xsl:attribute-set name="jaune">
  <xsl:attribute name="bgcolor">#FFFFD0</xsl:attribute>
</xsl:attribute-set>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table>
  <xsl:apply-templates />
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template match="produit">
 <xsl:choose>
  <xsl:when test="position() mod 2 = 0">
    <xsl:element nom="tr" use-attribute-sets="gris">
     <xsl:apply-templates />
    </xsl:element>
  </xsl:when>
  <xsl:otherwise>
    <xsl:element nom="tr" use-attribute-sets="jaune">
     <xsl:apply-templates />
    </xsl:element>
  </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template match="nom">
 <td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="prix">
 <td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML de l'exemple, il y a une liste avec des produits pour lesquels est noté à chaque fois le nom du produit et son prix. Dans la sortie HTML doit être créée sur ces bases un tableau dans lequel une rangée sur deux doit avoir un arrière-plan gris et les autres rangée, un arrière plan jaune. Pour cela deux schémas de jeux d'attributs correspondants sont définis dans la feuille de style de l'exemple avec xsl:attribute-set. Étant donné que pour chaque produit doit être créée une rangée de tableau, une requête est contenue dans chaque modèle qui contrôle la sortie HTML pour l'élément produit; cette requête vérifie à chaque élément actuel produit de la liste de données s'il s'agit d'un numéro de position pair. Si oui, une couleur d'arrière-plan grise est appliquée à la rangée de tableau actuelle, dans le cas contraire, une couleur jaune. La requête est contrôlée par les instructions xsl:choose, xsl:when et xsl:otherwise. Le numéro de position de chaque élément actuel est livré par la fonction position(). L'expression mod 2 = 0 demande si la division modulo de la valeur de la position donne 0, donc ne donne pas de reste et que le nombre est ainsi pair.
En fonction de la requête. un élément HTML tr, donc une rangée de tableau est créée dans les embranchements de when et de otherwise avec xsl:element. Cet élément HTML est doté avec les différents schémas d'attributs pour le jaune et pour le gris. Entre le repère d'ouverture et son pendant </xsl:element> les modèles subordonnés pour le nom et le prix du produit sont appelés.

xsl:fallback (instruction d'exécution en alternative)

Met à la disposition du processeur XSLT une instruction en alternative pour le cas où celui-ci ne connaîtrait pas une instruction XSLT récente ou moins courante.

n'a pas d'attributs.

Peut être placé dans xsl:template.

Fichier d'exemple `fallback.xml`:

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="fallback.xsl" ?>
<test>
<texte>Peu importe que tu dises A ou B , aussi longtemps que tu ne connais pas C.</texte>
<texte>Il vaut mieux ne pas parler de ce que l'on ne conna�t pas.</texte>
</test>

Fichier d'exemple `fallback.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 <xsl:processing-instruction name="xml-stylesheet">
  <xsl:fallback>
   <link rel="stylesheet" href="fallbacktest.css" type="text/css" />
  </xsl:fallback>
  <xsl:text>href="fallbacktest.css" type="text/css" ?</xsl:text>
 </xsl:processing-instruction>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="texte">
 <p><xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans la feuille de style de l'exemple, une feuille de style CSS a été incorporée dans l'arbre de transformation HTML avec l'instruction xsl:processing-instruction. Dans le cas ou le processeur XSLT ne connaissait pas cette instruction, une alternative est notée avec xsl:fallback, à savoir la notation directe de la commande d'incorporation de la feuille de style CSS.

xsl:for-each (répéter pour chacun des éléments d'une quantité)

Représente une instruction de boucle dans une définition de modèle. Ce qui figure dans la boucle sera appliqué à tous les nœuds à l'intérieur d'un jeu de nœuds à mentionner. Tous les nœuds suivants seront alors traités dans l'ordre. Il est ainsi possible par exemple de traiter tous les éléments element_liste, qui dépendent d'un élément nommé liste, directement à l'intérieur de la définition de modèle pour l'élément liste sans qu'il soit nécessaire d'appeler une définition de modèle subordonnée pour l'élément element_liste.

a les attributs suivants

select= (obligatoire) jeu de nœuds ou chemin d'après la syntaxe XPath, pour lequel la boucle doit s'appliquer.

Peut être placé xsl:template .

Fichier d'exemple `for_each.xml`:

Exemple d'affichage: aperçu (fichier de résultat for_each.htm)
Exemple d'affichage: aperçu (fichier for_each.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="for_each.xsl" ?>
<test>
<classe nom="6eme">
<ecolier>St�phane Jambon</ecolier>
<ecolier>Annie Cortier</ecolier>
<ecolier>Isabelle Perrault</ecolier>
</classe>
</test>

Fichier d'exemple `for_each.xsl`:

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

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

<xsl:template match="classe">
  <h3>classe <xsl:value-of select="@nom" /></h3>
  <p>
  <xsl:for-each select="ecolier">
    <xsl:value-of select="." /><br />
  </xsl:for-each>
  </p>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML de l'exemple sont notés les classes de l'école et les noms d'élèves. Dans la feuille de style de l'exemple une boucle est créée avec xsl:for-each dans le modèle pour l'élément classe, qui peut comporter autant d'éléments ecolier que souhaité. Dans cette boucle est créé dans l'arbre de transformation et dans l'ordre le contenu (xsl:value-of) de chaque élément ecolier ainsi qu'un passage à la ligne.

xsl:if (condition si)

Fait dépendre l'exécution d'une instruction d'une condition.

a les attributs suivants

test= (obligatoire) formule la condition.

Peut être placé dans xsl:template.

Fichier d'exemple `if.xml`:

Exemple d'affichage: aperçu (fichier de résultat if.htm)
Exemple d'affichage: aperçu (fichier if.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="if.xsl" ?>
<test>
<resultats><nom>Gaulois</nom><points>453</points></resultats>
<resultats><nom>Allobroges</nom><points>199</points></resultats>
<resultats><nom>Redoutables</nom><points>347</points></resultats>
<resultats><nom>Bayard</nom><points>106</points></resultats>
</test>

Fichier d'exemple `if.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:apply-templates />
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template match="resultats">
  <xsl:if test="points &gt;= 200">
    <tr>
    <xsl:apply-templates />
    </tr>
  </xsl:if>
</xsl:template>

<xsl:template match="nom">
 <td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="points">
 <td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML contiennent les résultats de jeu et cela avec les noms des joueurs et les points marqués. Dans la feuille de style de l'exemple un tableau HTML doit en être créé. Il faut pourtant que n'apparaissent dans le tableau que les joueurs qui totalisent 200 points ou plus. Pour ce faire, il est demandé dans le modèle qui contrôle la sortie HTML de l'élément XML resultats grâce à l'instruction <xsl:if test="points >= 200"> si le contenu de l'élément subordonné points est plus grand ou égal à 200. Dans l'affirmative une rangée de tableau est créée et les modèles pour les éléments subordonnés, donc pour nom et points sont appelés. Normalement l'opérateur pour "plus grand ou égal à" est tout simplement >=. Comme il est placé à l'intérieur d'une instruction basée sur XML, le signe plus grand que doit être transcrit en tant que Caractère propre à XML.
Les différentes possibilités de formuler des conditions avec xsl:if sont décrites dans la partie sur les opérateurs XPath.

xsl:import (importer des feuilles de style)

Importe des définitions de modèles d'autres feuilles de style qui peuvent ensuite être appliquées avec xsl:apply-imports à l'endroit désiré.

a les attributs suivants

href= (obligatoire) mentionne l'URI du fichier à importer.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Voir exemple dans xsl:apply-imports.

Attention:

En cas de contradiction, les définitions de feuilles de style définies dans la feuille de style actuelle ont priorité sur les définitions importées.

xsl:key (clé pour le choix d'éléments)

Définit une clé d'accès à des éléments ou attributs. Le travail du processeur XSLT en est facilité, ce qui peut augmenter la vitesse de traitement. La clé d'accès peut être appliquée par la fonction key().

a les attributs suivants

`name=`	(obligatoire) fixe un nom sous lequel la clé peut être employée.
`use=`	(obligatoire) mentionne à quoi la clé doit accéder.
`match=`	(facultatif) mentionne le jeu de nœuds ou le chemin d'après la syntaxe XPath où la clé doit s'ajouter dans l'arbre des éléments.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Fichier d'exemple `key.xml`:

Exemple d'affichage: aperçu (fichier de résultat key.htm)
Exemple d'affichage: aperçu (fichier key.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="key.xsl" ?>
<test>
<config type="utilisateur" nom="docroot" valeur="/usr/local/web" />
<config type="utilisateur" nom="cgibin" valeur="/usr/local/bin/cgi" />
<config type="expert" nom="timeout" valeur="60" />
</test>

Fichier d'exemple `key.xsl`:

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

<xsl:key name="utilisateur-seulement" match="config" use="@type"/>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:for-each select="key('utilisateur-seulement','utilisateur')">
   <tr>
    <td><xsl:value-of select="@nom" /></td>
    <td><xsl:value-of select="@valeur" /></td>
   </tr>
  </xsl:for-each>
 </table>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML représentent le contenu d'un fichier de configuration. Chaque élément de configuration représenté dans l'élément config, contient les données sous forme d'attributs. En plus des données typiques pour les éléments de configuration nom= et valeur= il y a aussi un attribut type=, dans lequel les valeurs utilisateur et expert sont permises. Cette information pourrait par exemple aider, quand, lors de l'affichage des données de configuration à un utilisateur annoncé comme utilisateur, les données du mode expert doivent lui être occultées. La feuille de style de l'exemple réalise une telle restriction. Une clé est définie avec <xsl:key name="utilisateur-seulement" match="config" use="@type"/>; elle accède à l'attribut type=. Pour être appliquée cette clé est placée dans l'instruction <xsl:for-each select="key('utilisateur-seulement','utilisateur')">. La clé définie auparavant et la valeur d'attribut désirée est renvoyée à la fonction key(). Seuls les éléments avec cette valeur d'attribut sont sortis.

xsl:message (sortir un message lors de la transformation)

Sort un message pendant la transformation des données. Utilisé habituellement pour le traitement d'erreur dans une condition.

a les attributs suivants

terminate= (facultatif) mentionne par yes ou par no (réglage par défaut) si le processus de transformation doit être interrompu ou non.

Peut être placé xsl:template .

Fichier d'exemple `message.xml`:

Exemple d'affichage: aperçu (fichier message.xml - Un navigateur XML/XSLT sort un message d'erreur)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="message.xsl" ?>
<test>
<chiffre_lotto>32</chiffre_lotto>
<chiffre_lotto>8</chiffre_lotto>
<chiffre_lotto>13</chiffre_lotto>
<chiffre_lotto>40</chiffre_lotto>
<chiffre_lotto>3</chiffre_lotto>
<chiffre_lotto>59</chiffre_lotto>
</test>

Fichier d'exemple `message.xsl`:

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

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

<xsl:template match="chiffre_lotto">
  <xsl:variable name="valeur_actuelle" select="."/>
  <xsl:if test="$valeur_actuelle > 49">
   <xsl:message terminate="yes">
    <xsl:text>Le chiffre </xsl:text>
    <xsl:value-of select="."/>
    <xsl:text>) est trop grand!</xsl:text><br />
   </xsl:message>
  </xsl:if>
  <xsl:value-of select="."/><br />
</xsl:template>

</xsl:stylesheet>

Explication:

Dans l'exemple sont notés des chiffres du lotto. La feuille de style de l'exemple formule dans la définition de modèle pour l'élément chiffre_lotto dans un premier temps une variable avec xsl:variable et lui affecte le contenu de l'élément actuel. Il est ensuite vérifié avec xsl:if si le contenu de la variable est plus grand que 49. Pour ce cas (erreur) un message d'erreur est construit avec xsl:message: il écrit, plutôt que le numéro de l'erreur, que le chiffre concerné est trop grand.

xsl:namespace-alias (transformer une feuille de style en une autre feuille de style)

permet de transformer une feuille de style en une autre feuille de style.

a les attributs suivants

`stylesheet-prefix=`	(obligatoire) mentionne le nom de l'espace de nommage qui est utilisé dans la feuille de style actuelle. Ce nom doit être attribué dans l'élément xsl:stylesheet avec l'attribut `xmlns:[Name]`.
`result-prefix=`	(facultatif) mentionne le nom de l'espace de nommage qui doit être employé à la place du nom mentionné dans `stylesheet-prefix=` dans la feuille de style de résultat.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Fichier d'exemple `namespace_alias.xml`:

Exemple d'affichage: aperçu (fichier de résultat namespace_out.htm - créé par le biais de namespace_out.xsl)
Exemple d'affichage: aperçu (fichier namespace_alias.xml)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="namespace_alias.xsl" ?>
<test>
<salut>hello monde</salut>
</test>

Fichier d'exemple `namespace_alias.xsl`:

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:out="namespace_out.xsl">

<xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/>

<xsl:template match="/">
 <out:stylesheet version="1.0">
  <out:template match="/">
   <html><head></head><body>
   <h1><xsl:value-of select="salut" /></h1>
   <h1><out:text>hello monde - par la feuille de style de sortie</out:text></h1>
   </body></html>
  </out:template>
 </out:stylesheet>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans la partie XML de l'exemple est noté simplement un salut "hello monde". Dans la feuille de style de l'exemple, la première particularité se trouve déjà dans le repère d'ouverture de l'élément xsl:stylesheet. L'attribut xmlns= y est noté deux fois: une fois pour la déclaration habituelle de l'espace de nommage (xmlns:xsl="http://www.w3.org/1999/XSL/Transform"), et une fois pour la déclaration d'un propre espace de nommage (xmlns:out="output.xsl">). Par l'instruction <xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/> est ensuite fixé pour le propre espace de nommage qui a reçu le nom out que la feuille de style actuelle soit transformée en feuille de style (output.xsl). Elle ne s'applique cependant que pour les notations qui mentionnent l'espace de nommage out. À l'intérieur de la définition de modèle de l'exemple sont définies de telles notations. La première commence par lt;out:stylesheet version="1.0">. La définition intérieure <xsl:value-of select="salut" /> ne sera pas reprise dans la feuille de style de sortie, à la place ce sera <out:text>hello monde - par la feuille de style de sortie</out:text>. Le code HTML qui est créé à la fin résulte de ce qui est défini dans la feuille de style de sortie.

xsl:number (numérotation continue)

Permet de numéroter en continu des éléments répétitifs de l'arbre de transformation.

a les attributs suivants

`count=`	(facultatif) Précise le ou les jeux de nœuds ou les chemins d'après la syntaxe XPath à l'occurrence desquels le compteur de numérotation doit être incrémenté.
`format=`	(facultatif) précise le genre de numérotation. Les mentions suivantes sont possibles: `1` = Genre de la numérotation 1, 2, 3, 4 ... `01` = Genre de la numérotation 01, 02, 03, 04, ... 10, 11 ... `a` = Genre de la numérotation a, b, c, d ... `A` = Genre de la numérotation A, B, C, D ... `i` = Genre de la numérotation i, ii, iii, iv ... `I` = Genre de la numérotation I, III, III, IV ... Le réglage par défaut est `1`. À la suite de cette mention sur le genre de numérotation peuvent encore suivre d'autres signes avec lesquels la numérotation est formatée. Ainsi par exemple on obtient avec la mention `1.` que derrière chaque nombre ordinal actuel respectif figure un point.
`from=`	(facultatif) précise le jeu de nœuds ou un chemin d'après la syntaxe XPath, à l'occurrence duquel la numérotation doit être arrêtée.
`grouping-separator=`	(facultatif) Signe de séparation pour des groupes de chiffres pour des nombres élevés par exemple le signe de séparation des milliers. Habituellement on utilise en français le point (`.`) pour l'écriture des nombres .
`grouping-size=`	(facultatif) Nombre des chiffres pour lequel le signe de séparation doit être posé: Pour le signe de séparation des milliers, la valeur serait `3`.
`lang=`	(facultatif) mentionne le pays (D'après RFC 1766), d'après les conventions de langues duquel la numérotation doit se faire. La mention doit se faire avec les abréviations du genre `de` (pour l'allemand), `en` (pour l'anglais), `fr` (pour le français).
`letter-value=`	(facultatif) Les valeurs permises sont `alphabetical` ou `traditional`. Une mention qui en plus de `lang=` est judicieuse pour certaines langues.
`level=`	(facultatif) Les valeurs permises sont `single`, `multiple` ou `any`. La mention se réfère à ce qui est mentionné pour `count=`. `single` signifie: L'algorithme de numérotation travaille sur le plan du niveau actuel de l'arborescence d'éléments et peut créer des numérotations du genre 1, 2, 3 ; si le nœud actuel correspond à la mention de `count=`, il est numéroté. `multiple` signifie: L'algorithme de numérotation travaille hiérarchiquement sur le niveaux actuel et tous les niveaux supérieurs de l'arborescence d'éléments et peut créer des numérotations du genre 1.1 ou 1.1.1 ; si le nœud actuel correspond à la mention de `count=`, il est numéroté. Ici chaque niveau supérieur de l'arborescence d'éléments est recherché pour savoir si la mention pour `count=` coïncide avec un nœud. À partir de ces informations est créée la numérotation hiérarchique. Pour `multiple` doit être mentionnée pour `count=` la séquence de nœuds pour lesquels doit s'appliquer la numérotation hiérarchique. Ceci est possible pour une mention telle que, par exemple `count="titre_chapitre\|titre_section\|soustitre"`. Les noms d'éléments doivent ici être séparés les uns des autres par des barres verticales (`\|`) . Pour l'attribut `format=` doit être noté dans ce cas quelque chose comme `format="1.1"` . `any` signifie: L'algorithme de numérotation travaille sur le plan du niveau actuel et tous les niveaux de l'arborescence d'éléments et peut créer des numérotations du genre 1, 2, 3; si le nœud actuel correspond à la mention de `count=`, il est numéroté. Ici est recherché dans chaque niveau supérieur de l'arborescence d'éléments si la mention de `count=` correspond à un nœud. La numérotation compte tous les nœuds ensemble.
`value=`	(facultatif) expression de calcul qui détermine la numérotation. Une mention possible est par exemple `value="position()"`.

Peut être placé dans xsl:template.

Fichier d'exemple `number.xml`:

Exemple d'affichage: aperçu (fichier de résultat number.htm)
Exemple d'affichage: aperçu (fichier number.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="number.xsl" ?>
<test>
<lien>http://selfhtml/selfhtml.com.fr/</lien>
<lien>http://selfforum/selfhtml.com.fr/</lien>
<lien>http://www.selfhtml.com.fr/</lien>
</test>

Fichier d'exemple `number.xsl`:

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

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

<xsl:template match="lien">
 <xsl:number level="single" count="lien" format="1. " />
 <a><xsl:attribute name="href"><xsl:value-of select="." /></xsl:attribute>
 <xsl:value-of select="." /></a><br />
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple contiennent une série de liens qui doivent être numérotés dans la sortie HTML. La feuille de style de l'exemple applique pour le faire l'instruction xsl:number à l'intérieur de la définition de modèle pour l'élément lien au début du code >HTML à créer. Une simple numérotation (level="single") doit être exécutée. Elle doit se poursuivre à chaque occurrence de l'élément lien (count="lien"). La numérotation doit être représentée sous la forme 1. ..., 2. ..., 3. ... grâce à (format="1. ").
Enfin un lien HTML est créé dans la définition de modèle qui présente le contenu de chaque élément lien sous une forme pouvant être cliquée.

xsl:otherwise (instruction autrement)

Détermine ce qui doit être fait quand une ou plusieurs conditions xsl:when ne sont pas remplies.

n'a pas d'attributs.

Peut être placé dans xsl:choose. Voir l'exemple à cet endroit.

xsl:output (contrôler la création de l'arbre de transformation)

Mentionne comment l'arbre de transformation doit être sorti ou écrit.

a les attributs suivants

`cdata-section-elements=`	(facultatif) pour `method="xml"`: précise les éléments dont le contenu doit être écrit dans des parties CDATA lors de la création de l'arbre de transformation (Comparez avec les Parties non interprétées (CDATA) ). Plusieurs éléments à séparer par des espaces peuvent être mentionnés.
`doctype-public=`	(facultatif) pour `method="xml"` et `method="html"`: quand le contrôle de validité de l'arbre de transformation se réfère à une affectation de DTD publique (public identifier) , cet attribut reçoit comme valeur la chaîne de caractères de l'identificateur public.
`doctype-system=`	(facultatif) pour `method="xml"` et`method="html"`: quand le contrôle de validité de l'arbre de transformation se réfère à une affectation de DTD adressée (system identifier), cet attribut reçoit comme valeur la chaîne de caractères de l'identificateur système.
`encoding=`	(facultatif) précise avec quel jeu de caractères l'arbre de transformation doit être codé. Une mention d'après RFC2278 est indiquée.
`indent=`	(facultatif) peut avoir comme valeur `yes` ou bien `no` (réglage par défaut). Avec `yes` l'arbre de transformation sera formaté de telle façon que les éléments subordonnés seront placés en retrait. Ceci n'a aucun effet sur la représentation mais est une mention "esthétique" pour une meilleure lisibilité du code-source généré.
`media-type=`	(facultatif) mentionne le type Mime de l'arbre de transformation. Avec `method="xml"` la mention `text/xml` est par exemple judicieuse, avec `method="html"` c'est par exemple `text/html` et avec `method="text"` c'est `text/plain`.
`method=`	(facultatif) mentionne de quelle façon l'arbre de transformation doit être créé. Les valeurs possibles sont `xml`, `html` (réglage par défaut), `text`, ou certains espaces de nommage publics ou privés XML.
`omit-xml-declaration=`	(facultatif) précise pour `method="xml"`, si dans l'arbre de transformation une déclaration XML (`<?xml ...?>`) doit être sortie ou non. Les valeurs possibles sont `yes` pour oui ou `no` pour non.
`standalone=`	(facultatif) précise pour `omit-xml-declaration="yes"`, que les déclarations DTD se trouvent dans le fichier actuel (comparer avec les Mentions supplémentaires pour le jeu de caractères et la référence DTD )
`version=`	(facultatif) précise pour `omit-xml-declaration="yes"` la mention de version XML.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Fichier d'exemple `output.xml`:

Exemple d'affichage: aperçu (fichier de résultat output_en.xml - Navigateur XML indispensable qui affiche la structure des données)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="output.xsl" ?>
<test>
<evenement>
  <description>8514 WW 13 � la vitesse de 95 dans une zone limit�e � 70</description>
  <pointeuse>13.05.2001,22:25</pointeuse>
</evenement>
</test>

Fichier d'exemple `output.xsl`:

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

<xsl:output method="xml" indent="yes" encoding="ISO-8859-1" omit-xml-declaration="yes" />

<xsl:template match="/">
 <test-en>
  <xsl:apply-templates />
 </test-en>
</xsl:template>

<xsl:template match="evenement">
 <event>
  <xsl:apply-templates />
 </event>
</xsl:template>

<xsl:template match="description">
 <description><xsl:value-of select="." /></description>
</xsl:template>

<xsl:template match="pointeuse">
 <timestamp><xsl:value-of select="." /></timestamp>
</xsl:template>

</xsl:stylesheet>

Explication:

Le données XML de l'exemple contiennent des "événements", tels qu'ils pourraient être tracés par une station radar dans le trafic routier. Les noms d'éléments sont en français. Dans une transformation contrôlée par XSL, ces données doivent figurer dans un fichier XML analogue avec la même arborescence d'éléments, le noms de ces derniers devant toutefois être mentionnés en anglais. Dans l'instruction xsl:output qui figure dans la feuille de style de l'exemple, avant les définitions de modèles, il est notifié à l'analyseur syntaxique XSL que l'arbre de transformation doit présenter une structure XML (method="xml"). Avec indent="yes" le formatage propre de la sortie de code-source XML est fixé et avec encoding="ISO-8859-1" est déterminé le jeu de caractères. Afin que la sortie XML reçoive une déclaration de type de document et une instruction de traitement, on a, grâce à omit-xml-declaration="yes", fait le nécessaire pour la déclaration XML . Dans les définitions de modèle suivantes, l'arbre de données du document de sortie avec des noms d'éléments en français est transcrit en un arbre de transformation avec des noms d'éléments en anglais.

xsl:param (définir un paramètre)

Définit un paramètre devant être utilisé avec xsl:with-param.

a les attributs suivants

`name=`	(obligatoire) mentionne le nom de variable du paramètre. Sous ce nom, il sera possible d'accéder à sa valeur.
`select=`	(facultatif) précise une valeur par défaut pour la variable du paramètre. Si cet attribut est mentionné, il s'agit d'un paramètre conçu pour être renvoyé d'une définition de modèle à une autre.

Peut être placé dans xsl:stylesheet et peut être placé aussi bien à l'intérieur qu'à l'extérieur de xsl:template. Quand il est noté à l'extérieur, c'est une variable globale à la disposition de toutes les définitions de modèles. Quand il est noté dans une définition de modèle, c'est une variable locale à l'intérieur du modèle.

Voir exemple dans xsl:with-param.

xsl:preserve-space (conserver les espaces)

Précise que les espaces contenus dans le fichier entre les éléments, sont conservés lors de la sortie. Les espaces sont des caractères avec les valeurs hexadécimales #x20 (simple espace), #x9 (signe de tabulation), #xD (retour en arrière) ou #xA (avance d'une ligne). Il ne s'agit pas du contenu texte d'éléments mais du formatage des éléments dans l'arbre de transformation.

a les attributs suivants

elements= (obligatoire) Nom d'un ou plusieurs éléments des données de sortie, dont les espaces doivent être conservés dans la sortie. Plusieurs mentions sont à séparer par des espaces.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Fichier d'exemple `preserve_space.xml`:

Exemple d'affichage: aperçu (fichier de résultat preserve_space.htm)
Exemple d'affichage: aperçu (fichier preserve_space.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="preserve_space.xsl" ?>
<test>


<contact>Germaine H�loire, gerloire@tiscali.net</contact>


<contact>Gaelle Amine, gamine@mails.org</contact>


</test>

Fichier d'exemple `preserve_space.xsl`:

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

<xsl:preserve-space elements="test" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body><pre>
  <xsl:apply-templates />
 </pre></body>
 </html>
</xsl:template>

<xsl:template match="contact">
  <b><xsl:value-of select="." /></b>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML un espace est noté entre les éléments à l'intérieur de l'élément document test. Dans la feuille de style de l'exemple, l'instruction <xsl:preserve-space elements="test" /> assure que ces espaces seront conservés lors de la sortie. Dans la définition de modèle pour la racine du document le contenu est alors inséré dans l'élément pre pour la sortie HTML, afin que les espaces aient un effet en HTML.

xsl:processing-instruction (générer un code de feuilles de style)

crée une instruction de traitement dans l'arbre de transformation.

a les attributs suivants

name= (obligatoire) précise le nom de l'instruction de traitement.

Peut être placé dans xsl:template.

Fichier d'exemple `processing_instruction.xml`:

Exemple d'affichage: aperçu (fichier de résultat processing.xml - navigateur XML/CSS indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="processing_instruction.xsl" ?>
<test>
<texte>Bonjour!</texte>
<texte>et au revoir!</texte>
</test>

Fichier d'exemple `processing_instruction.xsl`:

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

<xsl:output method="xml" omit-xml-declaration="no" />

<xsl:template match="/">
<xsl:processing-instruction name="xml-stylesheet">
 <xsl:text>href="processing.css" type="text/css"</xsl:text>
</xsl:processing-instruction>
 <test>
  <xsl:apply-templates />
 </test>
</xsl:template>

<xsl:template match="texte">
 <xsl:copy-of select="." />
</xsl:template>

</xsl:stylesheet>

Fichier d'exemple `processing.css`:

texte { font-size:21px; color:blue; }

Explication:

La feuille de style XSLT crée un nouveau fichier HTML dans lequel toutes les données du fichier d'entrée, dans l'exemple donc de processing_instruction.xml, sont copiées. Pour cela sert d'un côté l'instruction xsl:output, avec laquelle la déclaration XML pour le nouveau fichier HTML est créée, et d'autre part la copie des éléments texte à l'aide de xsl:copy-of dans l'arbre de transformation, donc le nouveau fichier XML. La différence entre le nouveau fichier XML créé avec l'ancien réside en ce qu'il contient une instruction de traitement pour incorporer une feuille de style. Pour cela est noté au début de la définition de modèle pour la racine du document / un élément xsl:processing-instruction avec le nom xml-stylesheet qui incorpore un fichier de feuilles de style externe. Ce qui a pour conséquence que les données XML sont sorties directement avec les formats du fichier CSS incorporé. Dans l'arbre de transformation l'instruction au processeur sera transcrite comme suit:
<?xml-stylesheet href="sortie.css" type="text/css" ?>
Les attributs dans l'exemple sont notés entre les repères d'ouverture et de fermeture de xsl:processing-instruction avec xsl:text.

xsl:sort (trier les éléments d'après leur contenu)

Trie les nœuds dans l'ordre d'après leur contenu. Ainsi par exemple tous les sous-éléments element_liste d'un élément nommé liste peuvent être triés alphabétiquement ou numériquement lors de la transformation.

a les attributs suivants

`case-order=`	(facultatif) précise si dans le tri, les majuscules viennent avant les minuscules ou le contraire. Les valeurs possibles sont `upper-first` (d'abord les majuscules) ou `lower-first` (d'abord les minuscules).
`data-type=`	(facultatif) précise si le tri doit se faire alphabétiquement (réglage par défaut) ou numériquement. Pour un tri alphabétique par exemple, `9` vient après `10`, pour un tri numérique `10` vient après `9`. Les valeurs possibles sont `text` (tri alphabétique) ou `number` (tri numérique).
`lang=`	(facultatif) mentionne le pays (d'après RFC 1766) d'après les conventions duquel le tri doit se faire. Ainsi par exemple la lettre `ê` en français (`lang="fr"`) sera classée autrement dans l'alphabet qu'en allemand (`lang="de"`).
`order=`	(facultatif) précise si le tri doit se faire dans l'ordre croissant (réglage par défaut), à savoir par exemple de A à Z, ou bien décroissant, à savoir par exemple de Z à A. Les valeurs possibles sont `ascending` (tri croissant) ou bien `descending` (tri décroissant).
`select=`	(facultatif) mentionne ce qui doit être trié. En l'absence de l'attribut, c'est le contenu de l'élément concerné qui est trié.

Peut être placé dans xsl:apply-templates ou bien dans xsl:for-each.

Fichier d'exemple `sort.xml`:

Exemple d'affichage: aperçu (fichier de résultat sort.htm)
Exemple d'affichage: aperçu (fichier sort.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="sort.xsl" ?>
<test>
<joueur><nom>Antoine</nom><points>12</points></joueur>
<joueur><nom>Patrick</nom><points>19</points></joueur>
<joueur><nom>Richard</nom><points>27</points></joueur>
<joueur><nom>William</nom><points>10</points></joueur>
</test>

Fichier d'exemple `sort.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:for-each select="test/joueur">
   <xsl:sort select="points" order="descending" data-type="number" />
   <tr>
   <td><xsl:value-of select="nom" /></td>
   <td><xsl:value-of select="points" /></td>
   </tr>
  </xsl:for-each>
 </table>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML contiennent des noms de joueur et les points marqués. Pour la sortie HTML cette liste sera triée dans l'ordre décroissant des points marqués. Pour ce faire une instruction xsl:sort est notée, dans la feuille de style de l'exemple, à l'intérieur de l'instruction xsl:for-each. L'instruction notée à cet endroit joue le rôle d'un filtre qui influence le traitement des différents éléments du type joueur. Comme critère de tri est mentionné points étant donné que le tri doit se faire d'après les points marqués. L'ordre de tri doit être décroissant (descending). Étant donné que les points marqués doivent être interprétés numériquement, la mention data-type="number" est encore notée. Enfin, les valeurs actuelles des éléments nom et points sont écrits dans le tableau HTML.

xsl:strip-space (contrôler le traitement des espaces)

Précise que les espaces entre les éléments qui sont contenus dans le fichier doivent être retirés dans la sortie. Les espaces sont des signes avec les valeurs hexadécimales #x20 (simple espace), #x9 (signe de tabulation), #xD (retour en arrière) ou #xA (avance d'une ligne). Il ne s'agit pas ici du contenu en texte d'éléments mais du formatage des éléments dans l'arbre de transformation.

a les attributs suivants

elements= (obligatoire) nom d'un ou plusieurs éléments des données de sortie dont les espaces doivent être supprimés dans la sortie. Plusieurs mentions sont à séparer par des espaces.

Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.

Fichier d'exemple `strip_space.xml`:

Exemple d'affichage: aperçu (fichier de résultat strip_space.htm)
Exemple d'affichage: aperçu (fichier strip_space.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="strip_space.xsl" ?>
<test>


<contact>Germaine H�loire, gerloire@tiscali.net </contact>


<contact>Gaelle Amine, gamine@mails.org</contact>


</test>

Fichier d'exemple `strip_space.xsl`:

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

<xsl:strip-space elements="test" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body><pre>
  <xsl:apply-templates />
 </pre></body>
 </html>
</xsl:template>

<xsl:template match="contact">
  <b><xsl:value-of select="." /></b>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML notées, un espace est placé entre les éléments à l'intérieur de l'élément document test. Dans la feuille de style de l'exemple l'instruction <xsl:strip-space elements="test" /> assure que ces espaces seront retirés lors de la sortie. Dans la définition de modèle pour l'élément racine le contenu est alors inséré dans l'élément pre pour la sortie HTML, afin que la disparition des espaces ait un effet en HTML.

xsl:stylesheet (élément racine de la feuille de style)

C'est l'élément racine d'une feuille de style qui contient toutes les définitions de style.

a les attributs suivants

`extension-element-prefixes=`	(facultatif) mentionne les espaces de nommage qui sont nécessaires à l'intérieur de la feuille de style, pour reconnaître des éléments de ces autres espaces de nommage. Une ou plusieurs mentions sont permises. Plusieurs mentions sont à séparer par des espaces.
`exclude-result-prefixes=`	(facultatif) mentionne les espaces de nommage qui sont nécessaires à l'intérieur de la feuille de style, pour reconnaître des éléments de ces autres espaces de nommage. Lors de la création de l'arbre de transformation, ces espaces de nommage ne sont pourtant pas transmis dans las mesure où ils n'y sont pas nécessaires. Une ou plusieurs mentions sont permises. Plusieurs mentions sont à séparer par des espaces.
`id=`	(facultatif) fixe pour la feuille de style un nom d'identification sans ambiguïté sous lequel elle pourra être adressée de l'"extérieur".
`version=`	(obligatoire) mentionne la version de langage XSL utilisée. Cette mention absolument indispensable est à l'heure actuelle `1.0`.
En outre l'élément `xsl:stylesheet` contient une ou plusieurs mentions sur l'espace de nommage qu'il utilise. Pour cela les sources des espaces de nommage doivent être mentionnées avec `xmlns:xsl=[source]`. Pour l'espace de nommage XSLT il faut mentionner habituellement `xmlns:xsl="http://www.w3.org/1999/XSL/Transform"`. Les différences avec ceci dépendent du processeur XSL employé.

Fichier d'exemple `stylesheet.xml`:

Exemple d'affichage: aperçu (fichier de résultat stylesheet.htm)
Exemple d'affichage: aperçu (fichier stylesheet.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="stylesheet.xsl" ?>
<test>
1234567890
</test>

Fichier d'exemple `stylesheet.xsl`:

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

<xsl:template match="/">
 <html><head></head>
 <body style="background-color:#000000; font-family:Algerian; font-size:80px; color:#33FF33">
  <xsl:value-of select="." />
 </body></html>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple ne contiennent que l'élément racine avec une suite de chiffres comme contenu. La feuille de style de l'exemple n'en est que plus simple. Avec xsl:template est définie une définition de modèle pour transcrire les données XML en sortie HTML. Ces définitions XSL et d'autres sont incluses dans l'élément racine xsl:stylesheet. Dans l'exemple le repère d'ouverture de cet élément contient les mentions typiques sur la version XSLT, sur la source XSLT et sur la source de l'espace de nommage HTML employé (ici: XHTML).

xsl:template (définir un modèle pour l'arbre de transformation)

Sert à définir des gabarits pour la transcription de l'arborescence de sortie en arbre de transformation. Pour cela est mentionné quel lien de l'arborescence de sortie doit être transcrit en quelle construction de l'arbre de transformation. Lors de la transformation de données XML personnelles en HTML, on peut par exemple à l'aide d'une telle définition de modèle transformer un élément nommé liste en élément de liste énumérative ul et les éléments subordonnés nommés element_liste peuvent être transformés en éléments HTML correspondants du type li.
L'élément xsl:template est ainsi le plus important et le plus significatif des éléments de XSLT.
La plupart du temps, l'arborescence de sortie (à savoir les données qui se trouvent dans une structure de données XML) et l'arbre de transformation (à savoir la structure de données dans laquelle il faut transcrire - par exemple HTML) sont si complexes qu'il n'est pas possible de tout régler dans une seule définition de modèle. À la place, des définitions de modèles peuvent appeler d'autres définitions de modèles avec xsl:apply-templates; elles traiteront par exemple les nœuds subordonnés.

a les attributs suivants

`match=`	(facultatif) mentionne pour quel jeu de nœuds ou quel chemin d'après la syntaxe XPath dans l'arborescence de sortie la définition de modèle doit s'appliquer. Si cet attribut n'est pas mentionné, il faut à la place mentionner `name=`.
`mode=`	(facultatif) attribue un nom pour le mode de la définition de modèle. Les modèles avec une mention de mode peuvent être choisis avec xsl:apply-templates.
`name=`	(facultatif) attribue un nom pour la définition de modèle. Sous ce nom, la définition de modèle peut être appelée avec xsl:call-template.
`priority=`	(facultatif) une valeur numérique qui règle les contradictions dans l'ordre de traitement des définitions de modèle. Dans quelques processeurs XSL, le règlement se fait jusqu'alors de telle façon que les modèles subordonnés ou les noms d'attributs ont normalement la valeur de priorité `0`. les modèles subordonnés ou les noms d'attributs avec mention de l'espace de nommage et et du caractère de remplacement `` ont la valeur de priorité `-0.25`. Un caractère de remplacement sans autre limitation `` a la valeur de priorité `-0.5`. Tous les autres modèles ont une valeur de priorité de `0.5`.

Peut être placé dans xsl:stylesheet.

Fichier d'exemple `template.xml`:

Exemple d'affichage: aperçu (fichier de résultat template.htm)
Exemple d'affichage: aperçu (fichier template.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="template.xsl" ?>
<test>
 <titre>Extension de fichier</titre>
 <glossaire>
  <element>
   <terme>bak</terme>
   <signification>fichier de sauvegarde</signification>
  </element>
  <element>
   <terme>bmp</terme>
   <signification>graphique Bitmap</signification>
  </element>
 </glossaire>
</test>

Fichier d'exemple `template.xsl`:

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

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

<xsl:template match="titre">
 <h1><xsl:value-of select="." /></h1>
</xsl:template>

<xsl:template match="glossaire/element">
 <p style="font-family:Arial,Helvetica,sans-serif; font-size:12pt">
  <xsl:apply-templates />
 </p>
</xsl:template>

<xsl:template match="terme">
 <b style="color:blue"><xsl:apply-templates />: </b>
</xsl:template>

<xsl:template match="signification">
  <xsl:value-of select="." />
</xsl:template>

</xsl:stylesheet>

Explication:

Le fichier contient dans les données XML une structure d'éléments imbriqués typique pour désigner dans ce cas une liste du genre glossaire d'extensions de fichiers avec leur signification. Dans la feuille de style de l'exemple cette structure d'éléments XML est transcrite en une structure HTML conforme à XML. Cela se produit à l'intérieur des définitions xsl:template. Ces définitions de modèle adressent habituellement un certain élément des données de sortie avec l'attribut match=. Comme contenu, la définition de modèle contient ensuite du code HTML et d'autres instructions XSL à l'aide desquels la transcription en HTML est contrôlée. Avec la première définition de modèle qui a pour mention match="/", l'élément racine des données XML est adressé (dans l'exemple c'est l'élément nommé test).
Pour créer un fichier HTML correct, l'ossature d'un fichier HTML est notée comme contenu de cette définition de modèle. Entre le repère d'ouverture et de fermeture body l'instruction XSL xsl:apply-templates est notée avec laquelle les définitions de modèle subordonnées qui traitent les éléments XML subordonnés, sont appelées. Ici, l'arborescence des données XML est décisive. Dans l'exemple ci-dessus l'élément racine des données XML a deux éléments qui lui sont immédiatement subordonnés, à savoir titre et glossaire. Pour l'élément titre une définition de modèle distincte est notée (<xsl:template match="titre">). À l'aide de l'instruction XSL xsl:value-of le contenu de l'élément titre y est transcrit en un titre HTML N� 1.
Pour l'élément glossaire il n'existe dans l'exemple aucune définition de modèle distincte, seulement à nouveau pour son élément subordonné element. Pour que ce modèle soit adressé par l'instruction <xsl:apply-templates />, qui est notée dans la définition de modèle de l'élément-racine, il est adressé d'après la syntaxe XPath avec glossaire/element. Chaque élément de glossaire de l'exemple est transcrit en un paragraphe HTML formaté en CSS. Y sont à leur tour appelées avec <xsl:apply-templates /> les définitions de modèle pour les éléments XML subordonnés. Dans l'exemple, ce sont les définitions pour les éléments subordonnés terme et signification.

xsl:text (sortir un contenu en caractères)

créée un texte statique dans l'arbre de transformation.

a les attributs suivants

disable-output-escaping= (facultatif) précise comment les signes propres à XML comme < ou bien > doivent être traités. Les valeurs possibles sont yes et no (réglage par défaut). Avec yes les signes ne sont pas changés dans leurs noms nommés, avec no ils le sont.

Peut être placé dans xsl:template.

Fichier d'exemple `textexsl.xml`:

Exemple d'affichage: aperçu (fichier de résultat textexsl.htm)
Exemple d'affichage: aperçu (fichier textexsl.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="textexsl.xsl" ?>
<test>
 <affirmation>Le monde est un village</affirmation>
</test>

Fichier d'exemple `textexsl.xsl`:

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

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

<xsl:template match="affirmation">
 <p><xsl:value-of select="." /></p>
<script type="text/javascript">
 <xsl:text>
  &lt;!--
   document.write(&quot;&lt;p&gt;&quot; + document.lastModified + &quot;&lt;/p&gt;&quot;);
  //--&gt;
 </xsl:text>
</script>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple contiennent une affirmation. Dans la feuille de style de l'exemple l'affirmation est transcrite en paragraphe. Au dessous est notée une instruction xsl:text pour créer du texte supplémentaire. À son tour celle-ci contient la notation conforme à HTML d'un petit JavaScript qui sort dans un paragraphe la date et l'heure de la dernière modification du fichier. Ainsi que l'instruction est notée dans l'exemple, les signes propres à XML doivent être masqués.

xsl:transform (élément racine de la feuille de style)

C'est un synonyme pour xsl:stylesheet.

xsl:value-of (sortir la valeur)

crée une chaîne de caractères sauvegardée à la position actuelle de l'arbre de sortie. Pour la chaîne de caractères sauvegardée, il peut s'agir par exemple du contenu d'un nœud de données XML ou bien du contenu d'une variable définie auparavant.

a les attributs suivants

`disable-output-escaping=`	(facultatif) précise comment les signes propres à XML comme `<` ou bien `>` doivent être traités. Les valeurs possibles sont `yes` et `no` (réglage par défaut). Avec `yes` les signes ne sont pas changés dans leurs noms nommés, avec `no` ils le sont.
`extension-element-prefixes=`	(facultatif) mentionne des espaces de nommage qui sont nécessaires pour reconnaître des éléments de ces autres espaces de nommage. Une ou plusieurs mentions sont permises. Plusieurs mentions sont à séparer par des espaces.
`select=`	(obligatoire) Choisit un nœud ou une variable ou un paramètre dont le contenu doit être utilisé.

Peut être placé dans xsl:template.

Fichier d'exemple `value_of.xml`:

Exemple d'affichage: aperçu (fichier de résultat value_of.htm)
Exemple d'affichage: aperçu (fichier value_of.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="value_of.xsl" ?>
<test>
 <liste>
   <element>Ma maison</element>
   <element>mon auto</element>
   <element>mon bateau</element>
 </liste>
</test>

Fichier d'exemple `value_of.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <ul>
  <xsl:apply-templates />
 </ul>
 </body>
 </html>
</xsl:template>

<xsl:template match="liste">
  <xsl:for-each select="element">
   <li><xsl:value-of select="." /></li>
  </xsl:for-each>
</xsl:template>

</xsl:stylesheet>

Explication:

Dans les données XML est définie une liste avec des éléments. Dans la feuille de style de l'exemple cette liste est transcrite en une liste énumérative HTML. Dans la définition de modèle pour l'élément liste est précisé avec xsl:for-each pour chacun des éléments subordonnés element, que leur contenu respectif qui est recherché avec <xsl:value-of select="." />, soit chacun transcrit en un élément de liste HTML li.
Avec select="." le contenu de l'élément actuel est choisi. En règle générale s'applique pour l'affectation de valeur à l'attribut select la syntaxe XPath.

xsl:variable (définir une variable)

Définit une variable dont la valeur peut être utilisée dans le reste du processus.

a les attributs suivants

name= (obligatoire) mentionne le nom de la variable. Sous ce nom, il peut être accédé à sa valeur.

select= (facultatif) précise une valeur pour la variable. Si cet attribut est noté, l'élément xsl:variable doit être vide. S'il n'est pas noté, l'affectation de valeur se fait comme contenu de l'élément entre son repère d'ouverture et son repère de fermeture. Avec select= un élément des données de sortie XML peut par exemple être choisi. Même l'occupation préalable avec du texte statique est possible par exemple avec select="'nom:'" (Faire attention ici aux apostrophes intérieures!).

Peut être placé dans xsl:stylesheet et peut être noté aussi bien à l'intérieur qu'à l'extérieur de xsl:template. Noté à l'extérieur, c'est une variable globale, à la disposition de toutes les définitions de modèles. Quand il est noté dans une définition de modèle, c'est une variable locale à l'intérieur du modèle.

Fichier d'exemple `variable.xml`:

Exemple d'affichage: aperçu (fichier de résultat variable.htm)
Exemple d'affichage: aperçu (fichier variable.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="variable.xsl" ?>
<test>
 <dicton>
   C'est un large champ
 </dicton>
 <dicton>
   La vie appartient � ceux qui se l�vent t�t
 </dicton>
 <dicton>
   Qui se l�ve tard fait du lard
 </dicton>
</test>

Fichier d'exemple `variable.xsl`:

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

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

<xsl:template match="dicton">
 <xsl:variable name="texteprecedent">
  <xsl:choose>
   <xsl:when test="position()=1">Premier �l�ment: </xsl:when>
   <xsl:when test="position()=last()">Dernier �l�ment: </xsl:when>
   <xsl:otherwise>�l�ment: </xsl:otherwise>
  </xsl:choose>
 </xsl:variable>
 <p><b><xsl:value-of select="$texteprecedent"/></b><br />
 <xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple contiennent une série de dictons. Dans la feuille de style de l'exemple une variable nommée texteprecedent est définie à l'intérieur de la définition de modèle pour l'élément dicton. Il s'agit d'une variable locale dont la valeur est recherchée de façon dynamique comme contenu entre le repère d'ouverture <xsl:variable...> et son pendant </xsl:variable>. C'est à cela que sert une instruction xsl:choose pour laquelle il est recherché par la fonction position() s'il s'agit du premier dicton, du dernier ou d'un dicton intermédiaire. En fonction de ceci un texte différent est créé: Premier élément, Dernier élément ou simplement seulement Élément. C'est la valeur qui est affectée à la variable texteprecedent. Étant donné que la définition de modèle est appelée à nouveau à chaque occurrence de l'élément dicton la valeur de la variable sera recherchée aussi à chaque fois.

xsl:when (condition à l'intérieur d'un choix)

Définit une condition à l'intérieur de l'instruction xsl:choose lors d'un choix multiple.

a les attributs suivants

test= (obligatoire) formule la condition.

Peut être placé dans xsl:choose.

Exemple avec explications voir xsl:choose, pour les conditions voir également xsl:if.

xsl:with-param (affecter une valeur à un paramètre)

affecte une valeur à un paramètre et cela à l'appel d'une définition de modèle. Dans la définition de modèle appelée et dans la mesure où le paramètre y est disponible, il est alors travaillé avec la valeur affectée.

a les attributs suivants

`name=`	(obligatoire) mentionne le nom du paramètre. Le paramètre doit être disponible sous ce nom dans une définition de modèle. Pour que le paramètre y soit disponible, il doit être défini avec xsl:param.
`select=`	(facultatif) affecte une valeur au paramètre. Avec `select=` un nœud des données de sortie XML peut être choisi. Ensuite la valeur affectée est le contenu de ce nœud. Cela peut être également une autre expression par exemple une formule de calcul. Même l'affectation de texte statique est possible, par exemple avec `select="'Nom'"` (Faire attention ici aux apostrophes intérieures!).

Peut être placé dans xsl:apply-templates ou bien xsl:call-template. La valeur affectée est alors disponible dans les définitions de modèles appelées.

Fichier d'exemple `with_param.xml`:

Exemple d'affichage: aperçu (fichier de résultat with_param.htm)
Exemple d'affichage: aperçu (fichier with_param.xml - navigateur XML/XSLT indispensable)

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="with_param.xsl" ?>
<test>
 <debut>10</debut>
 <fin>20</fin>
</test>

Fichier d'exemple `with_param.xsl`:

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

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:call-template name="boucle">
    <xsl:with-param name="compteur" select="number(/test/debut)" />
  </xsl:call-template>
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template name="boucle">
 <xsl:param name="compteur" />
 <xsl:choose>
  <xsl:when test="$compteur &lt;= number(/test/fin)">
    <tr>
      <td><xsl:value-of select="$compteur" /></td>
      <td><xsl:value-of select="$compteur * $compteur" /></td>
    </tr>
    <xsl:call-template name="boucle">
     <xsl:with-param name="compteur" select="$compteur + 1" />
    </xsl:call-template>
  </xsl:when>
  <xsl:otherwise>
   <xsl:call-template name="interruption" />
  </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="interruption">
 <xsl:comment>boucle termin�e!</xsl:comment>
</xsl:template>

</xsl:stylesheet>

Explication:

Les données XML de l'exemple définissent simplement un petit nombre et un nombre plus grand dont le premier représente une valeur de départ et le deuxième une valeur finale. Dans la feuille de style de l'exemple est créé à partir de ces nombres un tableau HTML; tous les nombres entre la valeur de départ et la valeur finale seront chacun placés sur une rangée du tableau avec son carré. Pour cela est appelée, dans la définition de modèle pour l'élément racine, une autre définition de modèle nommée boucle avec xsl:call-template. À l'intérieur de cette instruction xsl:call-template est notée une instruction xsl:with-param qui affecte à un paramètre nommé compteur une valeur avec select=. Dans ce cas c'est le contenu de l'élément debut (Chemin: /test/debut). Là on s'assure grâce à la fonction number() que le contenu de l'élément est interprété comme nombre.
Dans la définition de modèle appelée boucle, le paramètre nommé compteur est défini avec <xsl:param name="compteur" />. Il n'y a qu'ainsi qu'il est possible de travailler avec la valeur de ce paramètre qui lui a été transmise lorsqu'elle a été appelée. Il y aurait une alternative qui serait de définir compteur comme variable globale.
Avec <xsl:when test="$compteur <= number(/test/fin)"> Il est demandé si la valeur de compteur est plus petite ou égale à la valeur sauvegardée dans l'élément fin. Si c'est le cas une rangée de tableau est créée qui sort la valeur et son carré. Par ailleurs, le modèle boucle s'appelle lui-même en se renvoyant à nouveau le paramètre compteur. Celui-ci est incrémenté de 1, de telle façon que la définition de modèle à son prochain appel, demande le chiffre immédiatement supérieur.
Si la valeur de l'élément fin est dépassée, une définition de modèle nommée interruption est appelée qui pose somme toute un commentaire final dans le code HTML de sortie.


	Syntaxe XPath
	Exemples pour XSLT

SELFHTML/Aides à la navigation

XML/DTD

Représentation de données XML

Éléments XSLT

Fichier d'exemple apply_imports.xml:

Fichier d'exemple apply_imports1.xsl:

Fichier d'exemple apply_imports2.xsl:

Explication:

Fichier d'exemple apply_templates.xml:

Fichier d'exemple apply_templates.xsl:

Explication:

Fichier d'exemple attributes.xml:

Fichier d'exemple attributs.xsl:

Explication:

Fichier d'exemple attribute_set.xml:

Fichier d'exemple attribute_set.xsl:

Explication:

Fichier d'exemple call_template.xml:

Fichier d'exemple call_template.xsl:

Explication:

Fichier d'exemple choose.xml:

Fichier d'exemple choose.xsl:

Explication:

Exemple d'un extrait d'une feuille de style:

Explication:

Fichier d'exemple copy.xml:

Fichier d'exemple copy.xsl:

Explication:

Fichier d'exemple copy_of.xml:

Fichier d'exemple copy_of.xsl:

Explication:

Fichier d'exemple decimal_format.xml:

Fichier d'exemple decimal_format.xsl:

Explication:

Fichier d'exemple element.xml:

Fichier d'exemple element.xsl:

Explication:

Fichier d'exemple fallback.xml:

Fichier d'exemple fallback.xsl:

Explication:

Fichier d'exemple for_each.xml:

Fichier d'exemple for_each.xsl:

Explication:

Fichier d'exemple if.xml:

Fichier d'exemple if.xsl:

Explication:

Attention:

Fichier d'exemple key.xml:

Fichier d'exemple key.xsl:

Explication:

Fichier d'exemple message.xml:

Fichier d'exemple message.xsl:

Explication:

Fichier d'exemple namespace_alias.xml:

Fichier d'exemple namespace_alias.xsl:

Explication:

Fichier d'exemple number.xml:

Fichier d'exemple number.xsl:

Explication:

Fichier d'exemple output.xml:

Fichier d'exemple output.xsl:

Explication:

Fichier d'exemple preserve_space.xml:

Fichier d'exemple preserve_space.xsl:

Explication:

Fichier d'exemple processing_instruction.xml:

Fichier d'exemple processing_instruction.xsl:

Fichier d'exemple processing.css:

Explication:

Fichier d'exemple sort.xml:

Fichier d'exemple sort.xsl:

Explication:

Fichier d'exemple strip_space.xml:

Fichier d'exemple strip_space.xsl:

Explication:

Fichier d'exemple stylesheet.xml:

Fichier d'exemple stylesheet.xsl:

Explication:

Fichier d'exemple template.xml:

Fichier d'exemple template.xsl:

Explication:

Fichier d'exemple textexsl.xml:

Fichier d'exemple textexsl.xsl:

Fichier d'exemple `apply_imports.xml`:

Fichier d'exemple `apply_imports1.xsl`:

Fichier d'exemple `apply_imports2.xsl`:

Fichier d'exemple `apply_templates.xml`:

Fichier d'exemple `apply_templates.xsl`:

Fichier d'exemple `attributes.xml`:

Fichier d'exemple `attributs.xsl`:

Fichier d'exemple `attribute_set.xml`:

Fichier d'exemple `attribute_set.xsl`:

Fichier d'exemple `call_template.xml`:

Fichier d'exemple `call_template.xsl`:

Fichier d'exemple `choose.xml`:

Fichier d'exemple `choose.xsl`:

Fichier d'exemple `copy.xml`:

Fichier d'exemple `copy.xsl`:

Fichier d'exemple `copy_of.xml`:

Fichier d'exemple `copy_of.xsl`:

Fichier d'exemple `decimal_format.xml`:

Fichier d'exemple `decimal_format.xsl`:

Fichier d'exemple `element.xml`:

Fichier d'exemple `element.xsl`:

Fichier d'exemple `fallback.xml`:

Fichier d'exemple `fallback.xsl`:

Fichier d'exemple `for_each.xml`:

Fichier d'exemple `for_each.xsl`:

Fichier d'exemple `if.xml`:

Fichier d'exemple `if.xsl`:

Fichier d'exemple `key.xml`:

Fichier d'exemple `key.xsl`:

Fichier d'exemple `message.xml`:

Fichier d'exemple `message.xsl`:

Fichier d'exemple `namespace_alias.xml`:

Fichier d'exemple `namespace_alias.xsl`:

Fichier d'exemple `number.xml`:

Fichier d'exemple `number.xsl`:

Fichier d'exemple `output.xml`:

Fichier d'exemple `output.xsl`:

Fichier d'exemple `preserve_space.xml`:

Fichier d'exemple `preserve_space.xsl`:

Fichier d'exemple `processing_instruction.xml`:

Fichier d'exemple `processing_instruction.xsl`:

Fichier d'exemple `processing.css`:

Fichier d'exemple `sort.xml`:

Fichier d'exemple `sort.xsl`:

Fichier d'exemple `strip_space.xml`:

Fichier d'exemple `strip_space.xsl`:

Fichier d'exemple `stylesheet.xml`:

Fichier d'exemple `stylesheet.xsl`:

Fichier d'exemple `template.xml`:

Fichier d'exemple `template.xsl`:

Fichier d'exemple `textexsl.xml`:

Fichier d'exemple `textexsl.xsl`:

Fichier d'exemple `value_of.xml`:

Fichier d'exemple `value_of.xsl`:

Fichier d'exemple `variable.xml`:

Fichier d'exemple `variable.xsl`:

Fichier d'exemple `with_param.xml`:

Fichier d'exemple `with_param.xsl`: