SELFHTML/Aides à la navigation XML/DTD Représentation de données XML| SELFHTML/Aides à la navigation XML/DTD Représentation de données XML |
 |
Éléments XSLT |
|
|
 | |
L'élément xsl:stylesheet représente l'introduction logique d'un fichier XSL. Le plus important de ses éléments est l'élément xsl:template à l'aide duquel l'arbre de données XML est transcrit dans un arbre de transformation d'un autre langage conforme à XML (par exemple aussi HTML).
Lors de la description des éléments, il est souvent question de nœuds et de types de nœuds. Ces termes trouvent un début d'explication dans la partie sur les 
Nœuds et jeux de nœuds dans l'arborescence . Des explications plus approfondies à ce sujet se trouvent dans la partie sur la syntaxe XPath. Car XPath représente un langage complémentaire ou d'aide dans une feuille de style XSLT pour entre autres adresser précisément les parties constitutives d'un document XML. XPath a une spécification distincte comme XSLT.
Ne perdez pas de vue, en ce qui concerne l'Explorer Internet les Remarques sur les exemples.
|
xsl:apply-imports (appliquer des feuilles de style importées)Applique à l'intérieur d'un modèle défini avec xsl:template des modèles externes définis qui sont importés avec xsl:import.
N'attend aucun attribut.
Ne peut être placé que dans xsl:template.
Exemple d'affichage: aperçu (fichier de résultat apply_imports.htm)
Exemple d'affichage: aperçu (fichier apply_imports.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="apply_imports1.xsl" ?> <test> <image>pingouin.gif</image> <texte>Le pingouin est la marque distinctive de Linux</texte> </test> |
<?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> |
<?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> |
Dans le document XML apply_imports.xml la feuille de style apply_imports1.xsl est incorporée. Là et à l'aide de <xsl:import href="apply_imports2.xsl" /> une deuxième feuille de style est incorporée, à savoir apply_imports2.xsl. Dans la deuxième feuille de style, figurent des définitions pour la transcription HTML des éléments image et texte. Les définitions correspondantes sont appliquées dans la première feuille de style à l'endroit où <xsl:apply-imports/> est noté.
|
|
xsl:apply-templates (appliquer les modèles subordonnés)Applique à l'intérieur d'un modèle défini avec xsl:template d'autres modèles qui sont le cas échéant définis avec xsl:template. De cette manière, les dépendances et l'ordre lors de l'emploi de modèles peuvent être contrôlés.
a les attributs suivants:
select= |
(facultatif) choisit un modèle qui doit être appliqué. Le jeu de nœuds désiré est mentionné ou bien un chemin d'après la syntaxe XPath. Quand une définition xsl:template existe pour cet élément, elle est appliquée. Si l'attribut select manque, toutes les définitions xsl:template de l'échelon immédiatement inférieur sont appliquées. |
mode= |
(facultatif) Ne choisit le modèle mentionné avec select= que lorsqu'il a le mode mentionné. Pour cela il faut que lors de la définition de xsl:template un nom qui concorde ait été attribué pour le mode avec mode=. |
Peut être placé à l'intérieur de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat apply_templates.htm)
Exemple d'affichage: aperçu (fichier apply_templates.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="apply_templates.xsl" ?> <test> <texte> Ce que tu peux obtenir le <moment>lundi</moment> ne le repousse pas au <moment>mardi</moment>. </texte> </test> |
<?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> |
Dans l'exemple de feuilles de style, l'instruction <xsl:apply-templates /> (sans attribut) est placée deux fois. La première fois, elle est notée dans la définition de modèle de la racine du document. Là l'instruction figure dans le passage visible du code HTML à créer. à savoir entre <body> et </body>. Étant donné qu'aucun attribut select n'est mentionné, elle a pour effet qu'à l'endroit correspondant du code HTML, les modèles pour l'échelon pour les échelons immédiatement inférieurs sont appliqués. Dans la structure XML de l'exemple ce sont les éléments du type texte. Pour ces éléments, un modèle est défini avec <xsl:template match="texte">. Les éléments de ce type seront en HTML, inclus dans un paragraphe <p>...</p>qui est formaté avec les CSS. Pour le contenu du paragraphe l'avis s'applique pourtant une nouvelle fois: faire attention aux modèles subordonnés! C'est pourquoi l'instruction <xsl:apply-templates /> est notée à nouveau à l'intérieur du paragraphe de texte. Comme élément subordonné de texte dans l'exemple, l'élément moment peut être placé. Pour cet élément également un modèle a été défini avec <xsl:template match="moment">. Du texte placé dans ces éléments sera, en HTML, représenté en rouge et en italique.
´´Etant donné qu'à l'intérieur de l'élément moment il n'y a plus d'autres modèles subordonnés à prendre en considération, il ne faut plus considérer que le que le contenu respectif de l'élément. C'est ce qui est réalisé grâce à l'instruction <xsl:value-of select="." /> (voir aussi xsl:value-of).
|
|
xsl:attribute (créer un attribut dans l'arbre de transformation)Peut poser un attribut dans l'arbre de transformation et lui affecter une valeur, donc par exemple dans l'élément HTML div poser l'attribut align et lui affecter la valeur center.
a les attributs suivants:
name= |
(obligatoire) Mentionne le nom de l'attribut par exemple align. |
namespace= |
(facultatif) mentionne l'URI de l'espace de nommage dont provient l'attribut. |
Peut être placé à l'intérieur de xsl:template ou bien à l'intérieur de xsl:attribute-set.
Exemple d'affichage: aperçu (fichier de résultat attributs.htm)
Exemple d'affichage: aperçu (fichier attributs.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="attributs.xsl" ?> <test> <texte alignement="gauche"> Ceci est du texte aligné à gauche </texte> <texte alignement="centre"> Ceci est du texte centré </texte> <texte alignement="droite"> Ceci est du texte aligné à droite </texte> </test> |
<?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> |
Dans l'exemple, il y a un élément XML texte avec l'attribut alignement, qui peut prendre les valeurs gauche, droite et centre (d'après la DTD non mentionnés dans l'exemple). Dans les données XML trois élément du type texte sont notés, à chaque fois avec une valeur différente pour alignement. Dans la feuille de style de l'exemple, un modèle est défini avec <xsl:template match="texte"> pour l'élément texte. Le modèle a pour effet que les éléments du type texte seront transcrits en éléments HTML du type p. En le faisant, il faut pourtant également prendre en compte l'alignement du texte. Pour permettre de décider si, dans l'élément p, l'attribut align doit recevoir la valeur center, right ou left, il est recherché par des instructions xsl:choose, xsl:when et xsl:otherwise si l'élément à transcrire texte des données XML, a pour l'attribut alignement la valeur centre, droite ou gauche. Sous le module de requête le contenu de l'élément XML texte est finalement transcrit dans le contenu de l'élément HTML p grâce à l'instruction <xsl:value-of select="." />.
|
|
xsl:attribute-set (créer plusieurs attributs dans l'arbre de transformation)définit un ou plusieurs attributs pour l'arbre de transformation et cela séparément. Ceci est particulièrement indiqué pour définir comme blocs de texte des chaînes d'attributs utilisées fréquemment comme border="0" cellpadding="0" cellspacing="0", ou bien pour tenir à disposition des caractéristiques d'éléments en alternative par différents blocs de texte d'attributs.
a les attributs suivants:
name= |
(obligatoire) affecte un nom pour le jeu d'attributs. Sous ce nom, le jeu d'attributs peut ensuite être utilisé. |
use-attribute-sets= |
(facultatif) incorpore d'autres jeux d'attributs dans le jeu d'attributs actuel. Un ou plusieurs noms d'autres jeux d'attributs sont à mentionner. Plusieurs noms sont séparés par des espaces. |
Peut être placé à l'intérieur de xsl:stylesheet et doit être noté à l'extérieur de xsl:template. Peut être employé à l'intérieur d'un modèle par xsl:element ou xsl:copy, par leur attribut use-attribute-sets.
Exemple d'affichage: aperçu (fichier de résultat attribute_set.htm)
Exemple d'affichage: aperçu (fichier attribute_set.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="attribute_set.xsl" ?> <test> <element> <terme> HTML </terme> <definition> abréviation pour 'How To Make Love' </definition> </element> </test> |
<?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> |
L'exemple définit un glossaire. Les données contiennent un élément du glossaire. Dans la feuille de style de l'exemple le glossaire est transcrit en un tableau HTML. Au début de l'extrait d'exemple et en dehors des définitions de modèles, deux jeux d'attributs sont définis avec l'instruction attribute-set, l'un est nommé visible, et l'autre est nommé invisible. Entre le repère d'ouverture <xsl:attribute-set> et son pendant </xsl:attribute-set> des attributs sont définis à l'aide de xsl:attribute; ils pourront être employés plus tard dans les définitions de modèles. Dans l'exemple il s'agit d'attributs qui doivent trouver une utilisation plus tard dans l'élément table. Les deux jeux d'attributs définissent les attributs de telle façon qu'ils rendent possible pour l'un, la définition d'un tableau avec quadrillage et pour l'autre d'un tableau sans quadrillage.
À l'intérieur de la définition de modèle dans laquelle le tableau est créé, l'élément table est créé avec l'instruction
<xsl:element name="table" use-attribute-sets="visible">, cet élément aura les attributs qui ont été définis dans le jeu d'attributs nommé visible.
|
|
xsl:call-template (appeler un modèle)Appelle un autre modèle par son nom. Peut également renvoyer des valeurs de paramètres au modèle appelé.
a les attributs suivants
name= |
(obligatoire) le nom du modèle à appeler qui doit être défini avec <xsl:template name="..." [...]>. |
Peut être placé à l'intérieur de xsl:template. peut être noté sans contenu ou bien avec contenu et repère de fermeture. Sont permis comme contenu des éléments du type xsl:with-param.
Exemple d'affichage: aperçu (fichier de résultat call_template.htm)
Exemple d'affichage: aperçu (fichier call_template.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="call_template.xsl" ?> <test> <contact mail="est@aminet.net">Estelle Aminet</contact> </test> |
<?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> |
L'exemple XML contient des données de contact pour lesquelles sont notées dans l'élément contact le nom comme contenu; cet élément reçoit comme attribut l'affectation de l'adresse électronique correspondante.
Dans la feuille de style de l'exemple, un modèle est défini et nommé avec <xsl:template name="etiquette">. Dans ce modèle un texte statique a été défini avec xsl:text. À l'intérieur d'un autre modèle défini avec <xsl:template match="contact"> est noté un appel au modèle nommé etiquette et cela grâce à l'instruction <xsl:call-template name="etiquette" />. Dans l'exemple est ainsi créée, à partir des données XML <contact mail="est@aminet.net">Estelle Aminet</contact>, la sortie <div>Estelle Aminet, Courriel: est@aminet.net</div>.
|
|
xsl:choose (faire un choix)Forme le cadre d'une série de requêtes exécutées avec xsl:when et xsl:otherwise. La série peut être constituée du nombre souhaité de requêtes xsl:when et d'une instruction finale xsl:otherwise. La requête qui la première, répond à la condition sera choisie.
n'a pas d'attributs.
Peut être placé à l'intérieur de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat choose.htm)
Exemple d'affichage: aperçu (fichier choose.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="choose.xsl" ?> <test> <nombre>69</nombre> <nombre>12345</nombre> <nombre>743</nombre> <nombre>915743</nombre> </test> |
<?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 < 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> |
Une série de nombres sont notées dans les données XML de l'exemple et cela à chaque fois dans un élément nommé nombre. Dans la feuille de style de l'exemple le modèle est défini avec <xsl:template match="nombre">; il contrôlera la sortie HTML des nombres. La valeur du nombre est sortie avec <xsl:value-of select="." /> (voir également xsl:value-of). Enfin une variable nommée valeur est définie, qui repère la valeur donc le contenu placé entre <nombre> et </nombre>, (voir également xsl:variable). Une série de requêtes est ainsi introduite avec <xsl:choose> . Elle contient une requête xsl:when et une instruction xsl:otherwise. La requête xsl:when demande si la valeur de la variable valeur est plus petite que 10000. Si oui, le texte (un petit nombre) sera sorti à la suite du nombre déjà sorti, dans le cas contraire, ce sera le texte (un grand nombre). Pour la sortie de texte est utilisé xsl:text.
|
|
xsl:comment (mettre un commentaire)Inclut les sorties dans l'arbre de transformation dans des commentaires conformes à XML (également à HTML), de façon à ce que leur contenu ne soit pas sorti.
n'a pas d'attributs.
Peut être placé à l'intérieur de xsl:template.
<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>
|
Dans la feuille de style de l'exemple, un passage JavaScript est noté entre autres lors de la sortie HTML. Le contenu d'un tel passage doit être commenté pour le rendre inaccessible aux navigateurs ne supportant pas JavaScript. Dans l'exemple cela est réalisé à l'aide de l'instruction xsl:comment.
|
|
xsl:copy (copier un élément dans l'arbre de transformation)Copie un nœud actuel dans l'arbre de transformation à l'endroit où est notée l'instruction. Cela est judicieux par exemple quand les données XML contiennent des éléments pour lesquels un élément du même nom existe dans le langage de destination. Les repères d'élément et le contenu PCDATA sont copiés, mais pas les attributs, ni les éléments-enfants (voir également à ce sujet xsl:copy-of).
a les attributs suivants
use-attribute-sets= |
(facultatif) insérer dans la copie les attributs définis avec xsl:attribute-set. |
Peut être placé à l'intérieur de xsl:template. Peut avoir comme contenu tout ce qui est permis à l'intérieur de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat copy.htm)
Exemple d'affichage: aperçu (fichier copy.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="copy.xsl" ?> <test> <p>Si nous estimons meilleurs, nous ne le devenons pas pour autant</p> <p>On ne peut poser de pont qu'entre des rives séparées l'une de l'autre</p> </test> |
<?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> |
Les données XML de l'exemple sont composés d'aphorismes qui sont chacun inclus dans un élément XML nommé p. Dans la feuille de style de l'exemple, il a été fixé pour la définition du modèle pour les éléments du type p avec l'instruction <xsl:copy><xsl:value-of select="." /></xsl:copy> qu'ils soient tout simplement copiés dans l'arbre de transformation HTML. Cela se justifie étant donné que l'élément p signifie quelque chose en HTML et qu'il est formaté en conséquence par le navigateur. De cette manière, on obtient pour ce cas le même effet qui serait obtenu avec la définition de modèle suivante:
<xsl:template match="p">
<p><xsl:value-of select="." /></p>
</xsl:template>
|
|
xsl:copy-of (copier un ensemble de nœuds dans l'arbre de transformation)Copie dans l'arbre de transformation un nœud actuel et tout le jeu de nœuds qui en dépend, à l'endroit où l'instruction est notée. C'est judicieux par exemple pour répéter à plusieurs endroits le contenu s'un élément qui n'est noté qu'une fois dans les données.
a les attributs suivants
select= |
(obligatoire) choisir ce qui doit être copié. Cela peut être un jeu de nœuds ou un chemin d'après la syntaxe XPath ou encore une variable. |
Peut être placé à l'intérieur de xsl:template. Peut avoir comme contenu tout ce qui est permis à l'intérieur de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat copy_of.htm)
Exemple d'affichage: aperçu (fichier copy_of.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="copy_of.xsl" ?> <test> <titre>Téléphone</titre> <telephone><nom>Alexandre</nom><numero>0442 - 117273</numero></telephone> <telephone><nom>Marie</nom><numero>0320 - 558458</numero></telephone> </test> |
<?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> |
L'exemple définit une liste de numéros de téléphone, constituée de noms et de numéros de téléphone avec un titre qui est noté dans l'élément titre. Lors de la création de l'arbre de transformation dans la feuille de style de l'exemple, un tableau HTML à trois colonnes est cependant créé à partir de la liste de téléphone. Dans la première colonne figure à chaque fois le mot Téléphone. C'est le résultat de cette instruction qui grâce à <td><xsl:copy-of select="../titre" /></td> répète le titre, qui à vrai dire n'est placé qu'une fois, à chaque fois qu'est rencontré l'élément telephone. L'adressage de l'élément titre a lieu pour ce faire d'après l' adressage XPath avec mention de chemin relative en partant de l'élément telephone.
|
|
xsl:decimal-format (format décimal)Définit un schéma d'après lequel les nombres sont sortis dans l'arbre de transformation. Ce schéma peut être appliqué dans la fonction format-number().
a les attributs suivants
decimal-separator= |
(facultatif) Signe qui figure entre le nombre entier et les "chiffres après la virgule" pour séparer les deux groupes. En Français, c'est en principe une virgule, en Anglais un point. Le réglage par défaut est le point (.). |
digit= |
(facultatif) Signe placé comme "joker" pour un chiffre inconnu. Normalement c'est le signe dièse # (réglage par défaut). |
grouping-separator= |
(facultatif) Signe qui sépare un groupe de signes par exemple comme "signe des milliers". En Français, c'est en principe le point, en Anglais c'est la virgule. Le réglage par défaut est la virgule (,). |
infinity= |
(facultatif) Signe ou chaîne de caractères qui représente la valeur pour "infini" par exemple pour des valeurs périodiques après la virgule. Le réglage par défaut est Infinity. |
minus-sign= |
(facultatif) Signe qui précède une valeur négative. Normalement c'est le signe moins - (réglage par défaut). |
name= |
(facultatif) Nom du schéma défini. Sous ce nom, le schéma peut être utilisé dans la fonction format-number. Si aucun nom n'est donné, les définitions s'appliquent globalement. |
NaN= |
(facultatif) Chaîne de caractères qui exprime qu'une valeur n'est pas un nombre valide. Le réglage par défaut est NaN (not a number). |
pattern-separator= |
(facultatif) Signe qui figure entre la représentation de format d'un nombre positif et la représentation de format d'un nombre négatif. Le réglage par défaut est le point virgule (;). |
per-mille= |
(facultatif) Signe qui désigne des valeurs pour-mille. Le réglage par défaut est %O. |
percent= |
(facultatif) Signe qui désigne des valeurs pour cent. Le réglage par défaut est le signe de pourcentage %. |
zero-digit= |
(facultatif) Signe pour la représentation de zéros précédant un chiffre. Le réglage par défaut est le zéro 0. |
Peut être placé à l'intérieur de xsl:stylesheet et doit être noté à l'extérieur de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat decimal_format.htm)
Exemple d'affichage: aperçu (fichier decimal_format.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="decimal_format.xsl" ?> <test> <valeur>1230348345</valeur> <valeur>17235807</valeur> <valeur>12345</valeur> </test> |
<?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> |
Dans les données XML, différentes valeurs sont simplement notées et cela dans un élément nommé valeur. Dans la feuille de style de l'exemple, un schéma pour le formatage de nombres dans l'arbre de transformation est défini avec xsl:decimal-format. Le schéma contient le nom fr et détermine la virgule comme séparateur pour les nombres entiers et les positions décimales ainsi que le point pour séparer les groupes de milliers. Un modèle est défini pour l'élément du type valeur avec <xsl:template match="valeur">. Chaque valeur est sortie dans un élément HTML div. Avec l'instruction <xsl:value-of select="format-number(.,'#.##0,0','fr')"/> on se réfère au contenu de valeur, et cela par l'appel de la fonction format-number. Celle-ci reçoit entre parenthèses comme premier paramètre le point ., ce qui figure pour l'élément actuel. Le deuxième paramètre est une chaîne de format et le troisième le nom du schéma qui avait été défini auparavant avec xsl:decimal-format.
|
|
xsl:element (créer un élément)Crée un élément dans un arbre de transformation. Il est à vrai dire courant de noter directement des éléments dans l'arbre de transformation. Par exemple, lors de l'application de différents Attribut-Sets il peut être judicieux de ne pas noter les éléments directement dans l'arbre de transformation mais de les générer à l'aide de xsl:element. Un autre cas d'application est quand un arbre de transformation doit être créé à l'aide de XSL et que le langage de destination est lui-même XSL.
a les attributs suivants
name= |
(obligatoire) Nom de l'élément à générer par exemple table pour l'élément HTML du même nom |
namespace= |
(facultatif) Espace de nommage auquel l'élément appartient. |
use-attribute-sets= |
(facultatif) jeux d'attributs définis devant être placés dans le repère d'ouverture de l'élément à créer. |
Peut être placé xsl:template .
Exemple d'affichage: aperçu (fichier de résultat element.htm)
Exemple d'affichage: aperçu (fichier element.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="element.xsl" ?> <test> <produit><nom>Fauteuil à bascule</nom><prix>99,-</prix></produit> <produit><nom>Machine à café</nom><prix>49,95</prix></produit> <produit><nom>Tournevis</nom><prix>4,95</prix></produit> <produit><nom>Coussin</nom><prix>29,95</prix></produit> </test> |
<?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>
|
Dans les données XML de l'exemple, il y a une liste avec des produits pour lesquels est noté à chaque fois le nom du produit et son prix. Dans la sortie HTML doit être créée sur ces bases un tableau dans lequel une rangée sur deux doit avoir un arrière-plan gris et les autres rangée, un arrière plan jaune. Pour cela deux schémas de jeux d'attributs correspondants sont définis dans la feuille de style de l'exemple avec xsl:attribute-set. Étant donné que pour chaque produit doit être créée une rangée de tableau, une requête est contenue dans chaque modèle qui contrôle la sortie HTML pour l'élément produit; cette requête vérifie à chaque élément actuel produit de la liste de données s'il s'agit d'un numéro de position pair. Si oui, une couleur d'arrière-plan grise est appliquée à la rangée de tableau actuelle, dans le cas contraire, une couleur jaune. La requête est contrôlée par les instructions xsl:choose, xsl:when et xsl:otherwise. Le numéro de position de chaque élément actuel est livré par la fonction position(). L'expression mod 2 = 0 demande si la division modulo de la valeur de la position donne 0, donc ne donne pas de reste et que le nombre est ainsi pair.
En fonction de la requête. un élément HTML tr, donc une rangée de tableau est créée dans les embranchements de when et de otherwise avec xsl:element. Cet élément HTML est doté avec les différents schémas d'attributs pour le jaune et pour le gris. Entre le repère d'ouverture et son pendant </xsl:element> les modèles subordonnés pour le nom et le prix du produit sont appelés.
|
|
xsl:fallback (instruction d'exécution en alternative)Met à la disposition du processeur XSLT une instruction en alternative pour le cas où celui-ci ne connaîtrait pas une instruction XSLT récente ou moins courante.
n'a pas d'attributs.
Peut être placé dans xsl:template.
<?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> |
<?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> |
Dans la feuille de style de l'exemple, une feuille de style CSS a été incorporée dans l'arbre de transformation HTML avec l'instruction xsl:processing-instruction. Dans le cas ou le processeur XSLT ne connaissait pas cette instruction, une alternative est notée avec xsl:fallback, à savoir la notation directe de la commande d'incorporation de la feuille de style CSS.
|
|
xsl:for-each (répéter pour chacun des éléments d'une quantité)Représente une instruction de boucle dans une définition de modèle. Ce qui figure dans la boucle sera appliqué à tous les nœuds à l'intérieur d'un jeu de nœuds à mentionner. Tous les nœuds suivants seront alors traités dans l'ordre. Il est ainsi possible par exemple de traiter tous les éléments element_liste, qui dépendent d'un élément nommé liste, directement à l'intérieur de la définition de modèle pour l'élément liste sans qu'il soit nécessaire d'appeler une définition de modèle subordonnée pour l'élément element_liste.
a les attributs suivants
select= |
(obligatoire) jeu de nœuds ou chemin d'après la syntaxe XPath, pour lequel la boucle doit s'appliquer. |
Peut être placé xsl:template .
Exemple d'affichage: aperçu (fichier de résultat for_each.htm)
Exemple d'affichage: aperçu (fichier for_each.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="for_each.xsl" ?> <test> <classe nom="6eme"> <ecolier>Stéphane Jambon</ecolier> <ecolier>Annie Cortier</ecolier> <ecolier>Isabelle Perrault</ecolier> </classe> </test> |
<?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>
|
Dans les données XML de l'exemple sont notés les classes de l'école et les noms d'élèves. Dans la feuille de style de l'exemple une boucle est créée avec xsl:for-each dans le modèle pour l'élément classe, qui peut comporter autant d'éléments ecolier que souhaité. Dans cette boucle est créé dans l'arbre de transformation et dans l'ordre le contenu (xsl:value-of) de chaque élément ecolier ainsi qu'un passage à la ligne.
|
|
xsl:if (condition si)Fait dépendre l'exécution d'une instruction d'une condition.
a les attributs suivants
test= |
(obligatoire) formule la condition. |
Peut être placé dans xsl:template.
Exemple d'affichage: aperçu (fichier de résultat if.htm)
Exemple d'affichage: aperçu (fichier if.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="if.xsl" ?> <test> <resultats><nom>Gaulois</nom><points>453</points></resultats> <resultats><nom>Allobroges</nom><points>199</points></resultats> <resultats><nom>Redoutables</nom><points>347</points></resultats> <resultats><nom>Bayard</nom><points>106</points></resultats> </test> |
<?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 >= 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>
|
Les données XML contiennent les résultats de jeu et cela avec les noms des joueurs et les points marqués. Dans la feuille de style de l'exemple un tableau HTML doit en être créé. Il faut pourtant que n'apparaissent dans le tableau que les joueurs qui totalisent 200 points ou plus. Pour ce faire, il est demandé dans le modèle qui contrôle la sortie HTML de l'élément XML resultats grâce à l'instruction <xsl:if test="points >= 200"> si le contenu de l'élément subordonné points est plus grand ou égal à 200. Dans l'affirmative une rangée de tableau est créée et les modèles pour les éléments subordonnés, donc pour nom et points sont appelés. Normalement l'opérateur pour "plus grand ou égal à" est tout simplement >=. Comme il est placé à l'intérieur d'une instruction basée sur XML, le signe plus grand que doit être transcrit en tant que Caractère propre à XML.
Les différentes possibilités de formuler des conditions avec xsl:if sont décrites dans la partie sur les
opérateurs XPath.
|
|
xsl:import (importer des feuilles de style)Importe des définitions de modèles d'autres feuilles de style qui peuvent ensuite être appliquées avec xsl:apply-imports à l'endroit désiré.
a les attributs suivants
href= |
(obligatoire) mentionne l'URI du fichier à importer. |
Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.
Voir exemple dans xsl:apply-imports.
En cas de contradiction, les définitions de feuilles de style définies dans la feuille de style actuelle ont priorité sur les définitions importées.
|
|
xsl:key (clé pour le choix d'éléments)Définit une clé d'accès à des éléments ou attributs. Le travail du processeur XSLT en est facilité, ce qui peut augmenter la vitesse de traitement. La clé d'accès peut être appliquée par la fonction key().
a les attributs suivants
name= |
(obligatoire) fixe un nom sous lequel la clé peut être employée. |
use= |
(obligatoire) mentionne à quoi la clé doit accéder. |
match= |
(facultatif) mentionne le jeu de nœuds ou le chemin d'après la syntaxe XPath où la clé doit s'ajouter dans l'arbre des éléments. |
Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat key.htm)
Exemple d'affichage: aperçu (fichier key.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="key.xsl" ?> <test> <config type="utilisateur" nom="docroot" valeur="/usr/local/web" /> <config type="utilisateur" nom="cgibin" valeur="/usr/local/bin/cgi" /> <config type="expert" nom="timeout" valeur="60" /> </test> |
<?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>
|
Les données XML représentent le contenu d'un fichier de configuration. Chaque élément de configuration représenté dans l'élément config, contient les données sous forme d'attributs. En plus des données typiques pour les éléments de configuration nom= et valeur= il y a aussi un attribut type=, dans lequel les valeurs utilisateur et expert sont permises. Cette information pourrait par exemple aider, quand, lors de l'affichage des données de configuration à un utilisateur annoncé comme utilisateur, les données du mode expert doivent lui être occultées. La feuille de style de l'exemple réalise une telle restriction. Une clé est définie avec <xsl:key name="utilisateur-seulement" match="config" use="@type"/>; elle accède à l'attribut type=. Pour être appliquée cette clé est placée dans l'instruction <xsl:for-each select="key('utilisateur-seulement','utilisateur')">. La clé définie auparavant et la valeur d'attribut désirée est renvoyée à la fonction key(). Seuls les éléments avec cette valeur d'attribut sont sortis.
|
|
xsl:message (sortir un message lors de la transformation)Sort un message pendant la transformation des données. Utilisé habituellement pour le traitement d'erreur dans une condition.
a les attributs suivants
terminate= |
(facultatif) mentionne par yes ou par no (réglage par défaut) si le processus de transformation doit être interrompu ou non. |
Peut être placé xsl:template .
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> |
<?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>
|
Dans l'exemple sont notés des chiffres du lotto. La feuille de style de l'exemple formule dans la définition de modèle pour l'élément chiffre_lotto dans un premier temps une variable avec xsl:variable et lui affecte le contenu de l'élément actuel. Il est ensuite vérifié avec xsl:if si le contenu de la variable est plus grand que 49. Pour ce cas (erreur) un message d'erreur est construit avec xsl:message: il écrit, plutôt que le numéro de l'erreur, que le chiffre concerné est trop grand.
|
|
xsl:namespace-alias (transformer une feuille de style en une autre feuille de style)permet de transformer une feuille de style en une autre feuille de style.
a les attributs suivants
stylesheet-prefix= |
(obligatoire) mentionne le nom de l'espace de nommage qui est utilisé dans la feuille de style actuelle. Ce nom doit être attribué dans l'élément xsl:stylesheet avec l'attribut xmlns:[Name]. |
result-prefix= |
(facultatif) mentionne le nom de l'espace de nommage qui doit être employé à la place du nom mentionné dans stylesheet-prefix= dans la feuille de style de résultat. |
Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat namespace_out.htm - créé par le biais de namespace_out.xsl)
Exemple d'affichage: aperçu (fichier namespace_alias.xml)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="namespace_alias.xsl" ?> <test> <salut>hello monde</salut> </test> |
<?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> |
Dans la partie XML de l'exemple est noté simplement un salut "hello monde". Dans la feuille de style de l'exemple, la première particularité se trouve déjà dans le repère d'ouverture de l'élément xsl:stylesheet. L'attribut xmlns= y est noté deux fois: une fois pour la déclaration habituelle de l'espace de nommage (xmlns:xsl="http://www.w3.org/1999/XSL/Transform"), et une fois pour la déclaration d'un propre espace de nommage (xmlns:out="output.xsl">). Par l'instruction <xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/> est ensuite fixé pour le propre espace de nommage qui a reçu le nom out que la feuille de style actuelle soit transformée en feuille de style (output.xsl). Elle ne s'applique cependant que pour les notations qui mentionnent l'espace de nommage out. À l'intérieur de la définition de modèle de l'exemple sont définies de telles notations. La première commence par lt;out:stylesheet version="1.0">. La définition intérieure <xsl:value-of select="salut" /> ne sera pas reprise dans la feuille de style de sortie, à la place ce sera <out:text>hello monde - par la feuille de style de sortie</out:text>. Le code HTML qui est créé à la fin résulte de ce qui est défini dans la feuille de style de sortie.
|
|
xsl:number (numérotation continue)Permet de numéroter en continu des éléments répétitifs de l'arbre de transformation.
a les attributs suivants
count= |
(facultatif) Précise le ou les jeux de nœuds ou les chemins d'après la syntaxe XPath à l'occurrence desquels le compteur de numérotation doit être incrémenté. |
format= |
(facultatif) précise le genre de numérotation. Les mentions suivantes sont possibles:1 = Genre de la numérotation 1, 2, 3, 4 ...01 = Genre de la numérotation 01, 02, 03, 04, ... 10, 11 ...a = Genre de la numérotation a, b, c, d ...A = Genre de la numérotation A, B, C, D ...i = Genre de la numérotation i, ii, iii, iv ...I = Genre de la numérotation I, III, III, IV ...Le réglage par défaut est 1. À la suite de cette mention sur le genre de numérotation peuvent encore suivre d'autres signes avec lesquels la numérotation est formatée. Ainsi par exemple on obtient avec la mention 1. que derrière chaque nombre ordinal actuel respectif figure un point.
|
from= |
(facultatif) précise le jeu de nœuds ou un chemin d'après la syntaxe XPath, à l'occurrence duquel la numérotation doit être arrêtée. |
grouping-separator= |
(facultatif) Signe de séparation pour des groupes de chiffres pour des nombres élevés par exemple le signe de séparation des milliers. Habituellement on utilise en français le point (.) pour l'écriture des nombres . |
grouping-size= |
(facultatif) Nombre des chiffres pour lequel le signe de séparation doit être posé: Pour le signe de séparation des milliers, la valeur serait 3. |
lang= |
(facultatif) mentionne le pays (D'après RFC 1766), d'après les conventions de langues duquel la numérotation doit se faire. La mention doit se faire avec les abréviations du genre de (pour l'allemand), en (pour l'anglais), fr (pour le français).
|
letter-value= |
(facultatif) Les valeurs permises sont alphabetical ou traditional. Une mention qui en plus de lang= est judicieuse pour certaines langues. |
level= |
(facultatif) Les valeurs permises sont single, multiple ou any. La mention se réfère à ce qui est mentionné pour count=.single signifie: L'algorithme de numérotation travaille sur le plan du niveau actuel de l'arborescence d'éléments et peut créer des numérotations du genre 1, 2, 3 ; si le nœud actuel correspond à la mention de count=, il est numéroté.multiple signifie: L'algorithme de numérotation travaille hiérarchiquement sur le niveaux actuel et tous les niveaux supérieurs de l'arborescence d'éléments et peut créer des numérotations du genre 1.1 ou 1.1.1 ; si le nœud actuel correspond à la mention de count=, il est numéroté. Ici chaque niveau supérieur de l'arborescence d'éléments est recherché pour savoir si la mention pour count= coïncide avec un nœud. À partir de ces informations est créée la numérotation hiérarchique. Pour multiple doit être mentionnée pour count= la séquence de nœuds pour lesquels doit s'appliquer la numérotation hiérarchique. Ceci est possible pour une mention telle que, par exemple count="titre_chapitre|titre_section|soustitre". Les noms d'éléments doivent ici être séparés les uns des autres par des barres verticales (|) . Pour l'attribut format= doit être noté dans ce cas quelque chose comme format="1.1" .any signifie: L'algorithme de numérotation travaille sur le plan du niveau actuel et tous les niveaux de l'arborescence d'éléments et peut créer des numérotations du genre 1, 2, 3; si le nœud actuel correspond à la mention de count=, il est numéroté. Ici est recherché dans chaque niveau supérieur de l'arborescence d'éléments si la mention de count= correspond à un nœud. La numérotation compte tous les nœuds ensemble. |
value= |
(facultatif) expression de calcul qui détermine la numérotation. Une mention possible est par exemple value="position()". |
Peut être placé dans xsl:template.
Exemple d'affichage: aperçu (fichier de résultat number.htm)
Exemple d'affichage: aperçu (fichier number.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="number.xsl" ?> <test> <lien>http://selfhtml/selfhtml.com.fr/</lien> <lien>http://selfforum/selfhtml.com.fr/</lien> <lien>http://www.selfhtml.com.fr/</lien> </test> |
<?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> |
Les données XML de l'exemple contiennent une série de liens qui doivent être numérotés dans la sortie HTML. La feuille de style de l'exemple applique pour le faire l'instruction xsl:number à l'intérieur de la définition de modèle pour l'élément lien au début du code >HTML à créer. Une simple numérotation (level="single") doit être exécutée. Elle doit se poursuivre à chaque occurrence de l'élément lien (count="lien"). La numérotation doit être représentée sous la forme 1. ..., 2. ..., 3. ... grâce à (format="1. ").
Enfin un lien HTML est créé dans la définition de modèle qui présente le contenu de chaque élément lien sous une forme pouvant être cliquée.
|
|
xsl:otherwise (instruction autrement)Détermine ce qui doit être fait quand une ou plusieurs conditions xsl:when ne sont pas remplies.
n'a pas d'attributs.
Peut être placé dans xsl:choose. Voir l'exemple à cet endroit.
|
|
xsl:output (contrôler la création de l'arbre de transformation)Mentionne comment l'arbre de transformation doit être sorti ou écrit.
a les attributs suivants
cdata-section-elements= |
(facultatif) pour method="xml": précise les éléments dont le contenu doit être écrit dans des parties CDATA lors de la création de l'arbre de transformation (Comparez avec les Parties non interprétées (CDATA)
). Plusieurs éléments à séparer par des espaces peuvent être mentionnés. |
doctype-public= |
(facultatif) pour method="xml" et method="html": quand le contrôle de validité de l'arbre de transformation se réfère à une affectation de DTD publique (public identifier) , cet attribut reçoit comme valeur la chaîne de caractères de l'identificateur public. |
doctype-system= |
(facultatif) pour method="xml" 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  RFC2278 est indiquée. |
indent= |
(facultatif) peut avoir comme valeur yes ou bien no (réglage par défaut). Avec yes l'arbre de transformation sera formaté de telle façon que les éléments subordonnés seront placés en retrait. Ceci n'a aucun effet sur la représentation mais est une mention "esthétique" pour une meilleure lisibilité du code-source généré. |
media-type= |
(facultatif) mentionne le type Mime de l'arbre de transformation. Avec method="xml" la mention text/xml est par exemple judicieuse, avec method="html" c'est par exemple text/html et avec method="text" c'est text/plain. |
method= |
(facultatif) mentionne de quelle façon l'arbre de transformation doit être créé. Les valeurs possibles sont xml, html (réglage par défaut), text, ou certains espaces de nommage publics ou privés XML. |
omit-xml-declaration= |
(facultatif) précise pour method="xml", si dans l'arbre de transformation une déclaration XML (<?xml ...?>) doit être sortie ou non. Les valeurs possibles sont yes pour oui ou no pour non. |
standalone= |
(facultatif) précise pour omit-xml-declaration="yes", que les déclarations DTD se trouvent dans le fichier actuel (comparer avec les Mentions supplémentaires pour le jeu de caractères et la référence DTD
) |
version= |
(facultatif) précise pour omit-xml-declaration="yes" la mention de version XML. |
Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.
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> |
<?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> |
Le données XML de l'exemple contiennent des "événements", tels qu'ils pourraient être tracés par une station radar dans le trafic routier. Les noms d'éléments sont en français. Dans une transformation contrôlée par XSL, ces données doivent figurer dans un fichier XML analogue avec la même arborescence d'éléments, le noms de ces derniers devant toutefois être mentionnés en anglais. Dans l'instruction xsl:output qui figure dans la feuille de style de l'exemple, avant les définitions de modèles, il est notifié à l'analyseur syntaxique XSL que l'arbre de transformation doit présenter une structure XML (method="xml"). Avec indent="yes" le formatage propre de la sortie de code-source XML est fixé et avec encoding="ISO-8859-1" est déterminé le jeu de caractères. Afin que la sortie XML reçoive une déclaration de type de document et une instruction de traitement, on a, grâce à omit-xml-declaration="yes", fait le nécessaire pour la déclaration XML . Dans les définitions de modèle suivantes, l'arbre de données du document de sortie avec des noms d'éléments en français est transcrit en un arbre de transformation avec des noms d'éléments en anglais.
|
|
xsl:param (définir un paramètre)Définit un paramètre devant être utilisé avec xsl:with-param.
a les attributs suivants
name= |
(obligatoire) mentionne le nom de variable du paramètre. Sous ce nom, il sera possible d'accéder à sa valeur. |
select= |
(facultatif) précise une valeur par défaut pour la variable du paramètre. Si cet attribut est mentionné, il s'agit d'un paramètre conçu pour être renvoyé d'une définition de modèle à une autre. |
Peut être placé dans xsl:stylesheet et peut être placé aussi bien à l'intérieur qu'à l'extérieur de xsl:template. Quand il est noté à l'extérieur, c'est une variable globale à la disposition de toutes les définitions de modèles. Quand il est noté dans une définition de modèle, c'est une variable locale à l'intérieur du modèle.
Voir exemple dans xsl:with-param.
|
|
xsl:preserve-space (conserver les espaces)Précise que les espaces contenus dans le fichier entre les éléments, sont conservés lors de la sortie. Les espaces sont des caractères avec les valeurs hexadécimales #x20 (simple espace), #x9 (signe de tabulation), #xD (retour en arrière) ou #xA (avance d'une ligne). Il ne s'agit pas du contenu texte d'éléments mais du formatage des éléments dans l'arbre de transformation.
a les attributs suivants
elements= |
(obligatoire) Nom d'un ou plusieurs éléments des données de sortie, dont les espaces doivent être conservés dans la sortie. Plusieurs mentions sont à séparer par des espaces. |
Peut être placé dans xsl:stylesheet et doit être noté en dehors de xsl:template.
Exemple d'affichage: aperçu (fichier de résultat preserve_space.htm)
Exemple d'affichage: aperçu (fichier preserve_space.xml - navigateur XML/XSLT indispensable)
<?xml version="1.0" encoding="ISO-8859-1"?> <?xml-stylesheet type="text/xsl" href="preserve_space.xsl" ?> <test> <contact>Germaine Héloire, gerloire@tiscali.net</contact> <contact>Gaelle Amine, gamine@mails.org</contact> </test> |
<?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> |
Dans les données XML un espace est noté entre les éléments à l'intérieur de l'élément document test. Dans la feuille de style de l'exemple, l'instruction <xsl:preserve-space elements="test" /> assure que ces espaces seront conservés lors de la sortie. Dans la définition de modèle pour la racine du document le contenu est alors inséré dans l'élément pre pour la sortie HTML, afin que les espaces aient un effet en HTML.
|
|
xsl:processing-instruction (générer un code de feuilles de style)crée une instruction de traitement dans l'arbre de transformation.
a les attributs suivants
name= |
(obligatoire) précise le nom de l'instruction de traitement. |