SELFHTML

Éléments XSLT

Page d'information: vue d'ensemble

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

 vers le bas 

Remarques sur les éléments XSLT

L'élément vers le bas xsl:stylesheet représente l'introduction logique d'un fichier XSL. Le plus important de ses éléments est l'élément vers le bas 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 Autre page d'information Nœuds et jeux de nœuds dans l'arborescence . Des explications plus approfondies à ce sujet se trouvent dans la partie sur la Autre page d'information 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 Autre page d'information Remarques sur les exemples.

 vers le hautvers le bas 

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

Applique à l'intérieur d'un modèle défini avec vers le bas 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 vers le bas xsl:template.

Fichier d'exemple apply_imports.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat apply_imports.htm)
Démonstration - nouvelle fenêtre 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é.

 vers le hautvers le bas 

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

Applique à l'intérieur d'un modèle défini avec vers le bas 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 Autre page d'information 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 vers le bas xsl:template.

Fichier d'exemple apply_templates.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat apply_templates.htm)
Démonstration - nouvelle fenêtre 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 vers le bas xsl:value-of).

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:template ou bien à l'intérieur de vers le bas xsl:attribute-set.

Fichier d'exemple attributes.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat attributs.htm)
Démonstration - nouvelle fenêtre 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 vers le bas xsl:choose, vers le bas xsl:when et vers le bas 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="." />.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:stylesheet et doit être noté à l'extérieur de vers le bas xsl:template. Peut être employé à l'intérieur d'un modèle par vers le bas xsl:element ou vers le bas xsl:copy, par leur attribut use-attribute-sets.

Fichier d'exemple attribute_set.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat attribute_set.htm)
Démonstration - nouvelle fenêtre 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 vers le bas 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas 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 vers le bas xsl:with-param.

Fichier d'exemple call_template.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat call_template.htm)
Démonstration - nouvelle fenêtre 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 vers le bas 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>.

 vers le hautvers le bas 

XSLT1.0 xsl:choose (faire un choix)

Forme le cadre d'une série de requêtes exécutées avec vers le bas xsl:when et vers le bas 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 vers le bas xsl:template.

Fichier d'exemple choose.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat choose.htm)
Démonstration - nouvelle fenêtre 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 vers le bas 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 vers le bas 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é vers le bas xsl:text.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:copy-of).

a les attributs suivants

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

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

Fichier d'exemple copy.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat copy.htm)
Démonstration - nouvelle fenêtre 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>

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information syntaxe XPath ou encore une variable.

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

Fichier d'exemple copy_of.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat copy_of.htm)
Démonstration - nouvelle fenêtre 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'Autre page d'information adressage XPath avec mention de chemin relative en partant de l'élément telephone.

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information 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 vers le bas xsl:stylesheet et doit être noté à l'extérieur de vers le bas xsl:template.

Fichier d'exemple decimal_format.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat decimal_format.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut 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é vers le bas xsl:template .

Fichier d'exemple element.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat element.htm)
Démonstration - nouvelle fenêtre 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 vers le haut xsl:choose, vers le bas xsl:when et vers le bas xsl:otherwise. Le numéro de position de chaque élément actuel est livré par la fonction Autre page d'information 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas 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 vers le bas 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.

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information syntaxe XPath, pour lequel la boucle doit s'appliquer.

Peut être placé vers le bas xsl:template .

Fichier d'exemple for_each.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat for_each.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:template.

Fichier d'exemple if.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat if.htm)
Démonstration - nouvelle fenêtre 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 &gt;= 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 Autre page d'information Caractère propre à XML.
Les différentes possibilités de formuler des conditions avec xsl:if sont décrites dans la partie sur les Autre page d'information opérateurs XPath.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:stylesheet et doit être noté en dehors de vers le bas xsl:template.

Voir exemple dansvers le haut 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.

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information 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 Autre page d'information syntaxe XPath où la clé doit s'ajouter dans l'arbre des éléments.

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

Fichier d'exemple key.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat key.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

XSLT1.0 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é vers le bas xsl:template .

Fichier d'exemple message.xml:

Démonstration - nouvelle fenêtre 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 vers le bas xsl:variable et lui affecte le contenu de l'élément actuel. Il est ensuite vérifié avec vers le haut 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas 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 vers le bas xsl:stylesheet et doit être noté en dehors de vers le bas xsl:template.

Fichier d'exemple namespace_alias.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat namespace_out.htm - créé par le biais de namespace_out.xsl)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information 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 Autre page d'information 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 vers le bas xsl:template.

Fichier d'exemple number.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat number.htm)
Démonstration - nouvelle fenêtre 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://fr.selfhtml.org/</lien>
<lien>http://forum.fr.selfhtml.org/</lien>
<lien>http://actuel.fr.selfhtml.org/</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.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut xsl:choose. Voir l'exemple à cet endroit.

 vers le hautvers le bas 

XSLT1.0 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 Autre page d'information 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" etmethod="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 english page 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 Autre page d'information 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 Autre page d'information 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 Autre page d'information 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 vers le bas xsl:stylesheet et doit être noté en dehors de vers le bas xsl:template.

Fichier d'exemple output.xml:

Démonstration - nouvelle fenêtre 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 Autre page d'information 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.

 vers le hautvers le bas 

XSLT1.0 xsl:param (définir un paramètre)

Définit un paramètre devant être utilisé avec vers le bas 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 vers le bas xsl:stylesheet et peut être placé aussi bien à l'intérieur qu'à l'extérieur de vers le bas 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 dansvers le bas xsl:with-param.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:stylesheet et doit être noté en dehors de vers le bas xsl:template.

Fichier d'exemple preserve_space.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat preserve_space.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

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

crée une Autre page d'information 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 vers le bas xsl:template.

Fichier d'exemple processing_instruction.xml:

Démonstration - nouvelle fenêtre 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 vers le haut 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 vers le haut 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 vers le bas xsl:text.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut xsl:apply-templates ou bien dans vers le haut xsl:for-each.

Fichier d'exemple sort.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat sort.htm)
Démonstration - nouvelle fenêtre 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 vers le haut 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le bas xsl:stylesheet et doit être noté en dehors de vers le bas xsl:template.

Fichier d'exemple strip_space.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat strip_space.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

XSLT1.0 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:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat stylesheet.htm)
Démonstration - nouvelle fenêtre 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 vers le bas 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).

 vers le hautvers le bas 

XSLT1.0 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 vers le haut 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 Autre page d'information 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 vers le haut 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 vers le haut 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 vers le haut xsl:stylesheet.

Fichier d'exemple template.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat template.htm)
Démonstration - nouvelle fenêtre 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 vers le haut 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 vers le bas 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 Autre page d'information 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.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut xsl:template.

Fichier d'exemple textexsl.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat textexsl.htm)
Démonstration - nouvelle fenêtre 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.

 vers le hautvers le bas 

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

C'est un synonyme pour vers le haut xsl:stylesheet.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut xsl:template.

Fichier d'exemple value_of.xml:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat value_of.htm)
Démonstration - nouvelle fenêtre 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 vers le haut 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 Autre page d'information syntaxe XPath.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut xsl:stylesheet et peut être noté aussi bien à l'intérieur qu'à l'extérieur de vers le haut 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:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat variable.htm)
Démonstration - nouvelle fenêtre 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 vers le haut xsl:choose pour laquelle il est recherché par la fonction Autre page d'information 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.

 vers le hautvers le bas 

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

Définit une condition à l'intérieur de l'instruction vers le haut 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 vers le haut xsl:choose, pour les conditions voir également vers le haut xsl:if.

 vers le hautvers le bas 

XSLT1.0 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 vers le haut 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 vers le haut xsl:apply-templates ou bien vers le haut 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:

Démonstration - nouvelle fenêtre Exemple d'affichage: aperçu (fichier de résultat with_param.htm)
Démonstration - nouvelle fenêtre 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 Autre page d'information 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.

 vers le haut
page suivante Autre page d'information Syntaxe XPath
page précédente Autre page d'information Exemples pour XSLT
 

© 2001 Stefan Münz / © 2003 Traduction Adresse électronique Serge François, 13405@free.fr
Adresse électronique selfhtml@fr.selfhtml.org