SELFHTML/Aides à la navigation XML/DTD Représentation de données XML| SELFHTML/Aides à la navigation XML/DTD Représentation de données XML |
 |
Fonctions XPath |
|
|
 | |
Les fonctions de XPath ont pour mission de contrôler plus exactement la transcription des données de sortie XML dans l'arbre de transformation (par exemple en HTML) et de mettre à disposition pour le faire des propriétés supplémentaires. Elles sont conçues pour être utilisées dans des feuilles de style XSLT. Les différentes fonctions de XPath ont un rôle déterminé (par exemple l'extraction d'une sous-chaîne d'une chaîne de caractères) et retournent normalement une valeur (par exemple la sous-chaîne extraite).
Les fonctions comportent un nom de fonction suivi de parenthèses dans lesquelles peuvent figurer des arguments. Les arguments sont nécessaires pour qu'une fonction puisse remplir son rôle. Ainsi par exemple il faut faire savoir à la fonction qui extrait une sous-chaîne d'une chaîne de caractères quelle sous-chaîne elle doit extraire de quelle chaîne.
Pour la description des fonctions de cette partie, il sera décrit pour chacune d'entre elles si elle attend des arguments, et si oui lesquels. Quand plusieurs arguments sont indispensables, les différents arguments sont séparés par des virgules. Si une chaîne de caractères est notée comme argument, elle doit figurer entre guillemets. Étant donné que les fonctions XPath figurent la plupart du temps dans des affectations de valeur à des attributs d'éléments XSLT qui figurent déjà elles-mêmes entre guillemets, vous devez utiliser les autres guillemets. Si l'affectation de valeur à l'élément XSLT se trouve par exemple dans des guillemets doubles, une chaîne de caractères qui y est transmise à une fonction XPath, doit être placée dans des guillemets simples (apostrophes) donc par exemple comme ceci: <xsl:value-of select="document('datei2.xml')">. Les nombres et les noms d'éléments des données XML peuvent par contre être transmis sans guillemets.
Étant donné que les fonctions retournent une valeur, elles sont employées dans XSLT normalement à des endroits où les attributs se voient affecter une valeur. Ainsi par exemple l'élément XSLT 
value-of pourrait être noté sous la forme suivante:
<xsl:value-of select="last()" />
Ici est affectée à l'attribut select une valeur qui n'est pas fixe toutefois mais recherchée de façon dynamique. Dans ce cas, elle est recherchée par la fonction last().
De façon générale, il n'y a aucune garantie que tous les processeurs XSL, donc les logiciels d'interprétation XSL, connaissent toutes les fonctions XPath citées ici et qui font partie du standard XPath ou même qu'ils traitent toutes leurs possibilités.
Pour les descriptions des fonctions il sera souvent question de nœuds et de types de nœud. Ces termes ont été présentés dans la partie sur les Nœuds et jeux de nœuds dans l'arborescence. Des informations plus approfondies à ce sujet figurent dans la partie figurent dans la partie sur la syntaxe XPath.
|
boolean() (évaluer l'argument comme vrai ou faux)recherche si une expression est vraie ou fausse.
Attend les arguments suivants:
[expression] |
une expression quelconque pouvant être réalisée avec XSL et qui peut être évaluée comme vraie ou fausse. Il peut s'agir par exemple d'une comparaison mais aussi d'un test vérifiant l'existence d'un nœud. |
Renvoie true (vrai) ou bien false (faux).
<xsl:template match="nom">
<xsl:choose>
<xsl:when test="boolean(prenom) != boolean(patronyme)">
<xsl:message>Il faut mentionner soit le prénom et le nom,
ou ne pas mentionner de nom du tout!</xsl:message>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="prenom">
<xsl:apply-templates select="patronyme">
</xsl:otherwise>
</xsl:choose>
</xsl:template>
|
Dans l'exemple est défini un modèle pour un élément XML nommé nom. Il est supposé que cet élément contient deux éléments subordonnés prenom et patronyme. Dans la feuille de style de l'exemple, il est demandé avec <xsl:when test="boolean(prenom) != boolean(patronyme)"> si les deux éléments subordonnés ont une valeur ou si aucun n'a de valeur. Si ce n'est pas le cas, un message correspondant est sorti. Sinon, l'embranchement xsl:otherwise, qui appelle les modèles pour la transcription des éléments subordonnés, est exécuté.
|
|
ceiling() (arrondir un nombre)Arrondit par excès (au nombre entier supérieur) un nombre avec décimales. Le nombre 5.7234 est arrondi à 6, mais 0.00001 est aussi arrondi à 1. Il est important que les nombres avec décimales utilisent le point et non la virgule pour séparer les décimales. Dans le cas contraire ils sont interprétés comme nombre invalide (NaN - not a number).
Attend les arguments suivants:
[nombre] |
Le nombre à arrondir par excès. Il peut s'agir du contenu d'un nœud ou de celui d'une variable. Pour le faire, la valeur est d'abord transformée en nombre en interne, comme si la fonction number() avait été employée. |
retourne le nombre entier immédiatement supérieur.
<xsl:value-of select="ceiling(montant)"/><xsl:text>.-</xsl:text> |
Dans l'exemple il est supposé d'un élément XML nommé montant qu'il contient une valeur "crochue" devant être arrondie par excès au nombre entier d'euros supérieur. Pour ce faire, est appelée, lors du choix du contenu de montant avec xsl:value-of dans l'attribut select, la fonction ceiling(). Elle fait en sorte que le contenu de l'élément est arrondi par excès avant d'être pris dans l'arbre de transformation de la sortie de données.
|
|
concat() (concaténer des chaînes de caractères)Accroche plusieurs chaînes de caractères l'une à l'autre.
Attend les arguments suivants:
[chaîne de caractères], [chaîne de caractères], ... |
Accroche toutes les chaînes de caractères l'une à l'autre dans l'ordre donné. Il peut s'agir directement de texte, mais aussi du contenu d'un nœud ou de la valeur d'une variable. Les chaînes de caractères sont séparées par des virgules. |
Retourne la chaîne de caractères résultante.
<xsl:value-of select="concat(prenom, ' a pour nom de famille ', patronyme)"/> |
Dans l'exemple, il est supposé qu'il y a deux éléments XML disponibles prenom et patronyme. Lors de la transcription dans l'arbre de transformation, doit en résulter une phrase du type Isabelle a pour nom de famille Sanchez. Pour ce faire, la fonction concat() est utilisée dans l'attribut select lors du choix du contenu avec xsl:value-of. Elle reçoit comme paramètres trois chaînes de caractères: le contenu de l'élément prenom, la chaîne de caractères fixe a pour nom de famille, et le contenu de l'élément patronyme. Veillez à ce que les noms de variable, les noms d'éléments (ou les chemins d'élément d'après la syntaxe XPath) soient mentionnés directement, les chaînes de caractères fixes par contre incluses entre guillemets. Pour ce faire, il doit s'agir d'autres guillemets que ceux dans lesquels est placée la fonction. Si la fonction, comme dans l'exemple de l'attribut select, est placée dans les guillemets doubles "..." de ce dernier, il faut utiliser des apostrophes comme dans l'exemple ' a pour nom de famille '.
|
|
contains() (vérifier certaines sous-chaînes de caractères)Vérifie si une chaîne de caractères se trouve dans une chaîne de caractères déterminée.
Attend les arguments suivants:
[chaîne de caractères] |
La chaîne de caractères dans laquelle la vérification doit se faire. |
[sous-chaîne de caractères] |
La sous-chaîne de caractères qui doit être recherchée dans la chaîne de caractères. |
Retourne true quand la sous-chaîne de caractères est trouvée et false si elle ne l'est pas.
<xsl:if test="contains(patronyme, 'A')"> <xsl:value-of select="patronyme" /> </xsl:if> |
Dans l'exemple, il est vérifié avec xsl:if si la valeur d'un élément XML patronyme contient un A majuscule. Si oui, le contenu de l'élément est sorti. Pour cela, il est recherché avec contains(patronyme, 'A') - placé dans l'attribut select de l'instruction xsl:if - dans la chaîne de caractères sauvegardée dans l'élément patronyme si la sous-chaîne de caractères A se trouve. De cette façon par exemple, seuls les patronymes commençant par A passeront dans l'arbre de transformation.
|
|
count() (rechercher le nombre de nœuds dans un jeu de nœuds)Recherche le nombre de nœuds contenus sur le niveau inférieur à un jeu de nœuds.
Attend les arguments suivants:
[jeu de nœuds] |
Un jeu de nœuds ou un chemin d'après la syntaxe XPath, pour lequel le nombre de nœuds du niveau immédiatement inférieur doit être déterminé. |
Retourne le nombre des nœuds subordonnés.
<xsl:variable name="nombre" select="count(//elementliste)" />
...
<xsl:template match="liste">
<xsl:for-each select="elementliste">
<p>
<xsl:value-of select="position()" />
<xsl:text>e de </xsl:text>
<xsl:value-of select="$nombre"/>
<xsl:text>: </xsl:text>
<xsl:value-of select="." />
</p>
</xsl:for-each>
</xsl:template>
|
L'exemple suppose qu'il y a un élément XML nommé liste constitué de plusieurs sous-éléments elementliste. Dans un premier temps, une variable nommée nombre est définie avec xsl:variable; le nombre des éléments de la liste y sera sauvegardé. Pour cela la fonction count() est utilisée dans l'attribut select. L'élément elementliste lui est transmis comme argument. Dans la boucle for-each qui traite tous les éléments de la liste, le numéro de position actuelle est sorti devant le texte de chacun des éléments de la liste avec position() et derrière, le nombre total sauvegardé dans la variable nombre donc à peu près comme ça:
1e de 5: texte du premier élément de la liste
2e de 5: texte du deuxième élément de la liste
|
|
current() (rechercher le nœud actuel)Établit la relation au nœud respectivement actuel.
N'attend pas d'argument.
Retourne le jeu de nœuds qui contient le nœud actuel.
<xsl:value-of select="current()"/> |
L'instruction de l'exemple exprime la même chose que l'instruction habituelle:
<xsl:value-of select="."/>
current() et . donnent le même résultat quand current() figure dans une expression XPath inoccupée, donc par exemple directement dans un attribut select. Si par contre vous utilisez current() dans un prédicat (figure toujours entre [...]), le résultat retourné peut être différent du résultat retourné par select=".". La raison en est que XPath fait la différence en interne entre "current node" et "context node". Un "current node", donc un nœud actuel, n'est donné que lorsqu'un jeu de nœuds est traité dans l'ordre. Dans ce cas, c'est le nœud respectif traité qui est le "current node". En dehors d'un tel traitement en série, il n'y a cependant aucun "current node". Un "context node", comme on peut le rechercher par la syntaxe du point (.), est par contre donné à chaque instant.
|
|
document() (appeler un autre document XML)permet de prendre des données de sortie XML d'autres fichiers XML que celui dans lequel est incorporée la feuille de style, dans l'arbre de transformation.
Attend les arguments suivants:
[URI] |
Mention d'un fichier XML qui doit être incorporé. Il peut s'agir d'un adressage relatif ou d'une mention absolue, par exemple http://.... Si aucun autre fichier XML n'est mentionné mais un élément adressé avec la syntaxe XPath, alors c'est l'élément et le cas échéant son arborescence subordonnée qui seront incorporés à cet endroit. |
[jeu de nœuds] |
(facultatif) Mention de la base à l'intérieur des données incorporées à laquelle les adressages XPath peuvent se référer. On pense ici au premier nœud du jeu de nœuds. |
Retourne la structure d'éléments de l'autre fichier XML ou de l'élément mentionné à partir de l'élément racine.
<xsl:template match="exemple"> <pre> <xsl:value-of select="document(./@source)"/> </pre> </xsl:template> |
Dans l'exemple, il est supposé qu'il y a un élément XML nommé exemple, qu'un attribut contient une mention de source à un fichier XML, par exemple: <exemple source="../sources/exemple03.xml" />. Dans la feuille de style est défini pour la sortie HTML de cet élément un passage avec du texte pré-formaté avec <pre>...</pre>. Le contenu du fichier qui est mentionné dans l'attribut source= y est sorti avec xsl:value-of. Pour accéder au fichier, la fonction document() est utilisée dans l'attribut select. La mention sur l'attribut source= lui est transmise comme argument.
|
|
element-available() (vérifier si un élément XSLT est disponible)Recherche si un élément XSLT est disponible dans l'analyseur syntaxique XSLT utilisé ou non. Sert, pour cette raison comme mesure pour éviter les erreurs.
Attend les arguments suivants:
[nomelement] |
Nom d'un élément XSLT dont la disponibilité doit être vérifiée. |
Retourne true quand l'élément est disponible et false, s'il ne l'est pas.
<xsl:if test="element-available('xsl:number')">
<xsl:number level="single" count="element" format="1. " />
</xsl:if>
|
L'exemple vérifie à l'aide de l'instruction xsl:if si l'élément XSLT xsl:number est disponible. Si oui, il est appliqué dans l'instruction xsl:if. Si non, une erreur a au moins été évitée.
Cette fonction est également utile quand il s'agit de trouver si le processeur XSLT connaît des extensions spécifiques à un fabricant par exemple:
<xsl:when test="element-available('saxon:entity-ref')">...</xsl:when>.
Dans cette exemple, il est demandé si le processeur connaît l'élément entity-ref interprété par le processeur Saxon.
|
|
false() (créer une valeur booléenne pour "faux":)Nie une expression.
N'attend pas d'argument
Retourne simplement la valeur logique false.
<xsl:variable name="affichage_mot_passe" select="false()"/>
<xsl:template name="mot_passe">
<xsl:choose>
<xsl:when test="$affichage_mot_passe">
<xsl:value-of select="." />
</xsl:when>
<xsl:otherwise>
<xsl:text>[Mot de passe]</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
|
Dans l'exemple, une variable nommée affichage_mot_passe est définie avec xsl:variable dont la valeur est fixée sur la valeur logique false. Ceci est assuré par la mise en œuvre de la fonction false(), qui est tout simplement affectée à l'attribut select fixant ainsi la valeur. De plus, l'exemple montre une définition de modèle pour un élément nommé mot_passe. À l'intérieur de cette définition, il est demandé dans une construction xsl:choose quel est l'état de la variable d'affichage du mot de passe. Si la variable $affichage_mot_passe est vraie, la valeur de l'élément mot_passe est sortie avec <xsl:value-of select="." /> . Autrement seule la chaîne de caractères [Mot de passe] est sortie.
|
|
floor() (arrondir un nombre par défaut)Arrondit par défaut (au nombre entier inférieur) un nombre avec décimales. Le nombre 5.7234 est arrondi à 5 et le nombre 5.99997 est également arrondi à 5. Il est important que les "nombres avec virgule" utilisent le point comme séparateur de décimales. Autrement, ils sont interprétés comme nombres invalides (NaN - not a number).
Attend les arguments suivants:
[nombre] |
Le nombre à arrondir par défaut. Il peut s'agir également du contenu d'un nœud ou de la valeur d'une variable. Ici, la valeur est d'abord transformée en nombre en interne, et cela comme si la fonction number() avait été appliquée. |
Retourne le nombre entier obtenu.
<xsl:template match="nombre"> <div style="background-color:yellow"><xsl:value-of select="floor(./@valeur)" /></div> </xsl:template> |
L'exemple suppose un élément XML nommé nombre qui pourrait par exemple avoir les caractéristiques suivantes: <nombre valeur="63,47" />. Dans la définition de modèle pour la sortie HTML de cet élément, il est accédé à l'attribut avec @valeur. Ici cependant, l'accès à l'attribut est incorporé dans la fonction floor() de telle façon que, dans le cas d'un nombre avec la valeur 63,47, seul 63 n'apparaisse dans la sortie HTML.
|
|
format-number() (transformer un nombre en chaîne de caractères)Transforme un nombre en chaîne de caractères et permet d'influencer le formatage du nombre transformé.
Attend les arguments suivants:
[nombre] |
La valeur à transformer. Il peut s'agir également du contenu d'un nœud ou de la valeur d'une variable. Ici, la valeur est d'abord transformée en nombre en interne, et cela comme si la fonction number() avait été appliquée. |
[Règles de formatage] |
Une syntaxe de représentation pour le formatage du nombre transformé. La syntaxe des règles de formatage, se rapproche ici du schéma implémenté en Java 1.1 pour la classe decimal_format. À vrai dire, il n'existe aucune corrélation contraignante entre la syntaxe XPath et l'implémentation Java. Les signes suivants sont habituels:0 = un chiffre# = un chiffre, le 0 n'est toutefois pas affiché. = caractère de remplacement pour le point de séparation décimal, = caractère de remplacement pour un signe de séparation de groupes par exemple les milliers; = pour séparer plusieurs formats- = signe négatif devant comme réglage par défaut% = multiplier la valeur par 100 et afficher comme pourcentage? = multiplier la valeur par 1000 et afficher comme valeur pour mille¤ = symbole de devise, est remplacé par le symbole de devise par défaut (pas encore en Java 1.1!).' = pour masquer les signes ayant une signification pour le format comme 0, #, . etc...
|
[nom] |
(facultatif) Nom d'un format qui est défini avec xsl:decimal-format. |
Retourne une chaîne de caractères avec le nombre formaté.
<xsl:template match="valeur"> <xsl:value-of select="format-number(.,'##0.0%')"/> </xsl:template> |
L'exemple suppose un élément XML nommé valeur pour lequel un modèle est défini pour sa sortie dans l'arbre de transformation HTML. Là, le contenu de l'élément valeur est adressé par la fonction current() comme premier argument transmis à la fonction format-number() . Pour le formatage, il a été fixé que le nombre pouvait être à trois chiffres avec un chiffre après la virgule et que ce nombre devait être sorti comme valeur en pourcentage. Par l'affectation de cette construction à l'attribut select de xsl:value-of on obtient que le contenu de valeur soit sorti conformément aux règles de formatage.
|
|
function-available() (vérifier si une fonction XPath est disponible)Recherche si une fonction XPath est disponible dans l'analyseur syntaxique XSLT utilisé ou non. Sert, pour cette raison comme mesure pour éviter les erreurs.
Attend les arguments suivants:
[nom de fonction] |
Nom d'une fonction XPath dont la disponibilité doit être vérifiée. |
Retourne true quand la fonction est disponible et false, quand elle ne l'est pas.
<xsl:choose>
<xsl:when test="function-available('normalize-space')">
<xsl:value-of select="normalize-space(.)" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="." />
</xsl:otherwise>
</xsl:choose>
|
L'exemple vérifie à l'aide d'une construction xsl:choose si la fonction XPath normalize-space() est disponible. Si oui, elle est appliquée à l'intérieur de l'instruction xsl:value-of, pour retirer tous les espaces superflus au début et à la fin, lors de la sortie de l'élément actuel, mentionné avec .. Autrement, si la fonction n'est pas disponible, le contenu de l'élément actuel est sorti sans autre préparation préalable.
|
|
generate-id() (générer un identificateur clair pour un élément)Génère automatiquement un identificateur sans ambiguïté dans l'arbre de transformation. L'identificateur est le même à chaque processus de genèse (n'est donc pas créé par un algorithme basé sur l'heure et la date) mais dans tous les cas clair pour tout le document. L'identificateur généré répond en tout cas aux conventions pour les identificateurs en XML.
Attend les arguments suivants:
[jeu de nœuds] |
(facultatif) Un jeu de nœuds ou un chemin d'après la syntaxe XPath, qui doit recevoir un identificateur. |
Retourne une chaîne de caractères avec l'identificateur généré.
<xsl:template match="paragraphe">
<p><a name="{generate-id(.)}">
<xsl:value-of select="."/>
</a></p>
</xsl:template>
|
L'exemple définit un modèle pour un élément XML revenant souvent et nommé paragraphe. Chacun de ces éléments reçoit une ancre lors de la transcription en une construction HTML; cette ancre est définie avec <a name=>...</a>. La valeur qui est attribuée à chaque fois avec l'attribut name= est créée automatiquement et cela par l'application de la fonction generate-id(). Comme argument, l'élément actuel (.) est transmis. Les parenthèses accolades supplémentaires dans lesquelles figure la fonction pour l'attribution de valeur à name= sont importantes. Elles sont nécessaires parce que la fonction dans cet exemple ne figure pas comme affectation de valeur à l'attribut d'une instruction XSLT, mais à l'affectation à un attribut d'un élément de l'arbre de transformation - dans l'exemple, à l'attribut name de l'élément a du langage de résultat HTML.
generate-id() peut être également utilisé pour savoir si des nœuds sont identiques. Exemple:
<xsl:if test="a = b"> vérifie seulement si a et b ont le même contenu.
<xsl:if test="generate-id(a) = generate-id(b)"> vérifie par contre s'il est vrai que les deux nœuds sont identiques.
|
|
id() (choisir un élément avec un identificateur déterminé)Choisit un élément sur la base de son ID. Pour cela; L'élément doit posséder un attribut avec une valeur d'identification qui doit être défini comme tel dans la DTD correspondante. Étant donné que les affectations de valeur à ces attributs doit être sans ambiguïté pour tout le document, elles sont particulièrement bien appropriées choisir l'élément.
Attend les arguments suivants:
[valeur ID] |
La valeur ID de l'élément qui doit être choisi. |
Retourne l'élément ou plusieurs éléments dont la valeur ID a été choisie.
<xsl:template match="nom">
<li><xsl:value-of select="id('p01')" /><xsl:value-of select="." /></li>
</xsl:template>
|
L'exemple définit un modèle pour un élément nommé nom. Là est sortie une étiquette fixe dans un point de liste énumérative HTML (on pourrait imaginer par exemple une valeur comme nom, prenom: ) suivie de la valeur actuelle de l'élément nom avec <xsl:value-of select="." />. La valeur de l'étiquette est également recherchée avec une instruction xsl:value-of. Ici la fonction id()est notée dans l'attribut select. elle accède à un élément avec la valeur d'identification p01. Cet élément pourrait par exemple être noté dans les données XML de la façon suivante:
<prefix x="p01">nom, prenom: </prefix>
Là, l'attribut x serait défini dans la DTD correspondante en tant qu'attribut avec une valeur d'identification.
|
|
key() (choisir un élément grâce à une valeur-clé)Choisit un nœud qui possède une certaine valeur pour une clé nommée. Pratique pour , par exemple, ne choisir parmi tous les éléments que ceux qui remplissent certains critères en raison de leur contenu ou de l'affectation de valeur à leurs attributs.
Attend les arguments suivants:
[nom] |
Nom d'une clé. La clé elle-même doit auparavant avoir été définie à l'aide de l'instruction xsl:key et avoir reçu, dans l'attribut name de l'instruction, le nom mentionné ici. |
[valeur] |
La valeur qui sert à limiter les éléments à choisir. Seuls les éléments qui correspondent à la clé et qui ont cette valeur pour celle-ci seront choisis. |
Retourne le premier élément qui répond aux critères de choix.
<xsl:key name="k3" match="enregistrement" use="classecommerce" />
<xsl:template match="/">
<html><head><body>
<xsl:for-each select="key('k3','III')">
<xsl:apply-templates />
</xsl:for-each>
</body></html>
</xsl:template>
|
Dans l'exemple une clé nommée k3 est définie à l'aide de l'instruction xsl:key pour un élément nommé enregistrement; elle se réfère au contenu d'un élément nommé classecommerce subordonné à l'élément enregistrement. Il est supposé que les données XML sous leur élément-racine comprennent beaucoup d'éléments du type enregistrement. Par l'application de l'instruction xsl:for-each en relation avec la fonction key() dans l'attribut select ne sont choisis que les enregistrements dont l'élément subordonné classecommerce contient la valeur III. Dans ce cas, les définitions de modèles subordonnées sont appelées avec xsl:apply-templates.
|
|
lang() (vérifier un code de langue précis pour un élément)Vérifie si un élément utilise un code le langue déterminé. La condition en est que l'attribut XML xml:lang soit noté dans l'élément donc par exemple:
<description xml:lang="fr">La description de quelque chose</description>
Dans la DTD, la définition suivante serait indispensable:
<!ATTLIST description xml:lang NMTOKEN #IMPLIED>
Les mentions pour l'attribut xml:lang peuvent être des Abréviations de langue.
Attend les arguments suivants:
[chaîne de caractères] |
pour le code de pays pour lequel il faut vérifier (par exemple fr). |
Retourne true si l'élément mentionne ce code de pays dans son attribut xml:lang-, et false, quand aucun attribut xml:lang n'est défini ou si sa valeur est différente que celle transmise comme argument.
<xsl:template match="description">
<xsl:choose>
<xsl:when test="lang('fr')">
<h4><xsl:text>Description:</xsl:text></h4>
</xsl:when>
<xsl:otherwise>
<h4><xsl:text>Beschreibung:</xsl:text></h4>
</xsl:otherwise>
<p><xsl:value-of select="." /></p>
</xsl:choose>
</xsl:template>
|
L'exemple fait en sorte qu'un élément nommé description soit précédé dans l'arbre de transformation HTML par un titre h4. Il est vérifié ici avec l'instruction xsl:choose dans l'embranchement when et à l'aide de la fonction lang() si l'élément description contient xml:lang="fr" comme attribut. Si oui, le mot français Description est sorti comme texte du titre h4, dans le cas contraire, le mot allemand Beschreibung. À la fin, est encore sorti le contenu de l'élément description avec xsl:value-of.
|
|
last() (rechercher le numéro de position du dernier nœud d'une série)Recherche le numéro de position du dernier de plusieurs nœuds d'un jeu de nœuds.
N'attend pas d'argument.
Retourne le numéro de position du dernier nœud.
<xsl:template match="nombre"> <xsl:value-of select="." /> <xsl:if test="position() != last()"> <xsl:text>, </xsl:text> </xsl:if> </xsl:template> |
L'exemple définit un modèle pour un élément nommé nombre. Dans l'exemple, il est supposé que plusieurs de ces éléments sont notés les uns après les autres à l'intérieur d'un élément hiérarchiquement supérieur commun, donc par exemple, les différents chiffres dans une série de chiffres du lotto. À chaque application du modèle, est d'abord sorti le chiffre actuel avec xsl:value-of. Ensuite une virgule doit être sortie derrière tous les chiffres à part le dernier, de façon à créer une sortie du genre 3,15,28,29,33,43. Pour cela, il est demandé avec xsl:if si le numéro de position de l'élément actuel dans la série (recherché avec position()) est différent du (!=) numéro de position du dernier élément (recherché avec la fonction last()). Si c'est le cas, une virgule est sortie.
|
|
local-name() (rechercher le nom local d'un jeu de nœuds)Recherche à partir d'un nom de nœud et avec la mention de l'espace de nommage la partie du nom local- à partir d'un nom d'élément comme xhtml:blockquote on obtiendrait donc blockquote.
Attend les arguments suivants:
[jeu de nœuds] |
(facultatif) Un jeu de nœuds ou un chemin d'après la syntaxe XPath, dont le nom local doit être recherché. Si la mention de l'argument manque, la fonction s'applique à l'élément actuel. |
Retourne le nom local de l'élément dans la mesure où le nom d'élément existe aussi bien dans l'espace de nommage mentionné que le nom local d'élément. Dans le cas contraire, une chaîne de caractères vide est retournée.
<xsl:template match="auteur:*"> <div> <p>Nom du nœud: <b><xsl:value-of select="name(.)"/></b></p> <p>local-name:<b><xsl:value-of select="local-name(.)"/></b></p> <p>Contenu:<b><xsl:apply-templates /></b></p> </div> </xsl:template> |
L'extrait d'exemple montre une définition de modèle pour des éléments censés venir de l'espace de nommage auteur. En XML ce serait par exemple des éléments qui seraient notés sous la forme <auteur:prenom>...</auteur:prenom>. Le modèle recherche avec name(.) le nom complet du nœud actuel, à savoir par exemple auteur:prenom, et avec local-name(.) la partie du nom local, donc par exemple prenom. Enfin les définitions de modèles subordonnées sont appliquées avec xsl:apply-templates.
|
|
name() (rechercher le nom d'un jeu de nœuds)Recherche le nom complet d'un jeu de nœuds, le cas échéant avec mention de l'espace de nommage XML.
Attend les arguments suivants:
[jeu de nœuds] |
(facultatif) Un jeu de nœuds ou un chemin d'après la syntaxe XPath, dont le nom complet doit être recherché. Si la mention de l'argument manque, la fonction est appliquée sur l'élément actuel. |
Retourne le nom du nœud choisi.
<xsl:template name="Descriptif"> <b><xsl:value-of select="name()" /><xsl:text>: </xsl:text></b><xsl:value-of select="." /> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé Descriptif. Dans ce modèle il est défini que le nom de l'élément est d'abord sorti, donc Descriptif, puis deux points et ensuite le contenu de l'élément. La sortie du nom d'élément est obtenue par l'instruction xsl:value-of qui reçoit comme affectation de valeur pour l'attribut select, la fonction name().
|
|
namespace-uri() (rechercher l'espace de nommage d'un élément)Recherche l'URI pour l'espace de nommage employé pour la DTD. Il s'agit en principe de mentions qui ont été faites dans l'attribut xmlns: de l'instruction xsl:stylesheet. La condition préalable en est, pour qu'une valeur soit retournée, qu'un élément utilise une mention d'espace de nommage, donc par exemple xsl:template ou bien xhtml:div.
Attend les arguments suivants:
[jeu de nœuds] |
(facultatif) Un jeu de nœuds ou un chemin d'après la syntaxe XPath, dont le nom local doit être recherché. Si la mention de l'argument manque, la fonction est appliquée sur l'élément actuel. |
Retourne l'URI qui a été renvoyée pour l'espace de nommage correspondant à l'élément.
<?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>
<b><xsl:text>URI de cette feuille de style XSL: </xsl:text></b>
<xsl:value-of select="namespace-uri(document('')/*)" />
</body></html>
</xsl:template>
</xsl:stylesheet>
|
L'exemple montre une feuille de style complète XSLT. Dans le repère d'ouverture stylesheet est notée comme d'habitude avec xmlns:xsl="http://www.w3.org/1999/XSL/Transform" l'URI de la DTD pour l'espace de nommage XSL. Plus loin dans la feuille de style est défini un modèle pour l'élément-racine. Dans ce modèle n'est cependant simplement sortie que l'URI de l'espace de nommage XSL pour cette feuille de style. Pour le faire, la fonction namespace-uri() est passée comme valeur de l'attribut select pour l'instruction xsl:value-of. La sortie dans l'exemple serait:
URI de cette feuille de style XSL: http://www.w3.org/1999/XSL/Transform
Dans l'exemple, document('')/* est passé comme argument à la fonction namespace-uri(). Cela s'explique ainsi: l'élément document doit être recherché, ce qui est le plus simple réaliser par la fonction document('') (avec la chaîne vide comme paramètre). Avec l'astérisque qui termine /*, l'URI de l'espace de nommage est recherchée pour tous les éléments dans l'élément document, étant donné que toute l'expression se trouve dans un appel de namespace-uri().
|
|
normalize-space() (retirer les espaces au début et à la fin d'une chaîne de caractères)Résume plusieurs espaces au début ou à la fin d'une chaîne de caractères en un seul espace. Les espaces sont les signes avec les valeurs hexadécimales #x20 (espace simple), #x9 (tabulation), #xD (retour de chariot) ou #xA (avance d'une ligne).
Attend les arguments suivants:
[chaîne de caractères] |
(facultatif) La chaîne de caractères qui doit être traitée. Si l'argument manque, la fonction est appliquée au contenu de nœud du nœud actuel, pour un élément <name>...</name> par exemple à son contenu donc par ce qui est marqué ici par trois points. |
Retourne la chaîne de caractères traitée.
<xsl:template match="couleur_yeux"> <tr> <td><xsl:text>couleur des yeux</xsl:text></td> <td><xsl:value-of select="normalize-space()" /></td> </tr> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé couleur_yeux. Une rangée de tableau HTML y est construite. Dans la première colonne figure le texte fixe couleur des yeux, et dans la deuxième colonne, la valeur de l'élément. Ici cependant, les espaces placés avant ou après et pouvant provenir par exemple d'un manque d'attention lors de l'édition ou du traitement par d'autres programmes, sont ôtés. Pour obtenir ce résultat, il n'est pas simplement noté <xsl:value-of select="." /> mais <xsl:value-of select="normalize-space()" />.
|
|
not() (nier un argument)nie l'argument transmis et retourne comme résultat son contraire.
Attend les arguments suivants:
[condition] |
Il peut s'agir d'une comparaison mais aussi d'une autre fonction retournant comme valeur soit true ou bien false. |
Retourne true quand la condition transmise en argument donne false comme résultat et false, si la condition donne true comme résultat.
<xsl:template match="anniversaire"> <xsl:if test="not(. > '1980')"> <xsl:value-of select="." /> </xsl:if> </xsl:template> |
L'exemple montre une définition de modèle d'un élément XML nommé anniversaire. L'année de naissance ne doit être sortie que lorsque la valeur actuelle n'est pas plus grande que 1980. Pour cela, une condition est formulée à l'aide de l'instruction xsl:if. Dans l'attribut test qui contient la condition, est formulée avec . > '1980' la condition "valeur actuelle plus grande que 1980". La fonction complète est pourtant transmise comme argument à la fonction not(), ce qui fait que la condition est inversée et s'intitule: "valeur actuelle pas plus grande que 1980". C'est d'ailleurs la même chose que si la condition avait été ainsi notée: <xsl:if test=". <='1980')">
|
|
number() (transformer un argument en nombre)Essaie d'interpréter en tant que nombre une chaîne de caractères transmise et retourne le nombre recherché. Si par exemple "31" est transmis, 31 est retourné. Si "xyz" est transmis, NaN (not a number) est retourné. Pour la transmission de "3xy", 3 est retourné. Et pour la transmission de valeurs booléennes, donc de true ou bien de false, 0 est retourné pour false et 1 est retourné pour true. Les espaces placés en tête ou à la fin de la chaîne de caractères transmise sont ignorés.
Attend les arguments suivants:
[chaîne de caractères ou bien valeur] |
(facultatif) Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable ou de la valeur retournée par une autre fonction. Si l'argument manque, la fonction est appliquée au contenu du nœud actuel par exemple au contenu d'un élément. |
Retourne le nombre recherché.
<xsl:template match="prix"> <xsl:value-of select="number()" /> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé prix. Le modèle sort la valeur de l'élément en essayant toutefois d'interpréter numériquement sa valeur. Pour cela, la fonction number() est appliquée dans l'attribut select de l'instruction xsl:value-of. Étant donné qu'aucun argument n'est transmis à number() la fonction se réfère à la valeur de l'élément actuel prix.
|
|
position() (rechercher le numéro de position du jeu de nœuds actuel)Recherche le classement d'un nœud actuel dans un jeu de nœuds. Pour un élément nommé liste avec par exemple 7 éléments subordonnés nommés element_liste le deuxième de ces éléments a, par rapport à liste le numéro de position 2.
N'attend pas d'argument.
Retourne le numéro de classement du nœud actuel. Pour le premier nœud 1, pour le deuxième 2 etc...
<xsl:variable name="nombre" select="count(//element_liste)" />
...
<xsl:template match="liste">
<xsl:for-each select="element_liste">
<p>
<xsl:value-of select="position()" />
<xsl:text>e sur </xsl:text>
<xsl:value-of select="$nombre"/>
<xsl:text>: </xsl:text>
<xsl:value-of select="." />
</p>
</xsl:for-each>
</xsl:template>
|
L'exemple suppose qu'il y a un élément XML nommé liste qui comporte plusieurs éléments subordonnés element_liste. D'abord une variable nommée nombre est définie avec xsl:variable dans laquelle le nombre des éléments de la liste est sauvegardé. Pour le faire, la fonction count() est appliquée dans l'attribut select. L'élément element_liste lui est transmis comme argument. Dans la boucle for-each qui traite tous les éléments de la liste, le numéro actuel respectif de position est sorti avant le texte de l'élément avec position() suivi du nombre total qui est sauvegardé dans la variable nombre, donc à peu près comme ça:
1e sur 5: texte du premier élément de la liste
2e sur 5: texte du deuxième élément de la liste
<xsl:value-of select="element_liste[position()=1]" /> peut également être noté de la façon suivante:
<xsl:value-of select="element_liste[1]" />
<xsl:value-of select="element_liste[position()=last()]" /> peut également être noté de la façon suivante:
<xsl:value-of select="element_liste[last()]" />
<xsl:if test="position()=1"> est quelque chose d'autre que <xsl:if test="1">! Dans le premier cas, il est vérifié si le nœud traité actuellement est le premier, dans le second cas, il est vérifié si le contexte actuel est vrai sur un plan logique.
|
|
round() (arrondi par excès ou par défaut commercial)Arrondit un nombre avec décimales au nombre entier le plus proche. Pour des fractions de valeur plus petites que [valeur],5 l'arrondi se fait par défaut, pour des fractions de valeur plus grandes ou égales à [valeur],5 l'arrondi se fait par excès. Le nombre 5,49 est donc arrondi par défaut à 5 et 5,5 est arrondi par excès à 6.
Attend les arguments suivants:
[nombre] |
Le nombre à arrondir. Il peut aussi s'agir du contenu d'un nœud ou d'une variable. Ici la valeur est d'abord transformée en interne en nombre et cela comme si la fonction number() était appliquée. |
Retourne un nombre entier auquel l'arrondi s'est fait par excès ou par défaut.
<xsl:value-of select="round(montant)"/><xsl:text >.-</xsl:text> |
Dans l'exemple il est supposé d'un élément XML nommé montant qu'il contient une valeur "crochue" devant être arrondie de façon commerciale. Pour ce faire, lors du choix du contenu de montant avec xsl:value-of la fonction round() est appelée dans l'attribut select. Elle obtient que le contenu de l'élément soit arrondi avant d'être pris dans l'arbre de transformation de la sortie des données.
|
|
starts-with() (vérifier si une chaîne de caractères commence par une certaine sous-chaîne)Trouve si au début d'une chaîne de caractères se trouve une certaine sous-chaîne de caractères.
Attend les arguments suivants:
[chaîne de caractères] |
Chaîne de caractères dans laquelle il faut chercher. Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable. |
[sous-chaîne de caractères] |
La chaîne de caractères qui doit être recherchée au début de la chaîne de caractères où la recherche doit se faire. Il peut s'agir directement de texte, mais aussi du contenu d'un nœud ou de la valeur d'une variable. |
Retourne true si la chaîne de caractères commence par la sous-chaîne de caractères, et false, si elle ne commence pas par cette sous-chaîne.
<xsl:template match="nom_employe"> <p> <xsl:if test="starts-with(.,'Madame')"> <b><xsl:value-of select="." /></b> </xsl:if> <xsl:if test="starts-with(.,'Monsieur')"> <i><xsl:value-of select="." /></i> </xsl:if> </p> </xsl:template> |
Dans l'exemple, un modèle a été défini pour un élément XML nommé nom_employe. Pour cela il est demandé avec xsl:if si le contenu de l'élément commence par Madame ou par Monsieur. Dans le cas où il commence par "Madame" le nom est écrit en caractères gras dans l'arbre de transformation HTML. Les éléments qui commencent par Monsieur sont par contre écrits en italique. La requête xsl:if utilise à cet effet la fonction starts-with(). Le contenu du nœud actuel (.) est transmis comme paramètre à la fonction ainsi que la chaîne de caractères, critère de recherche Madame ou bien Monsieur.
|
|
string() (transformer un argument en chaîne de caractères)Interprète un argument transmis en tant que chaîne de caractères et renvoie la chaîne de caractères recherchée. Si par exemple 31 est transmis, "31" est retourné. Les chiffres négatifs reçoivent un signe moins qui les précèdent, les nombres avec décimales, un point décimal. Pour la transmission de valeurs booléennes, donc true ou bien false, "true" ou "false" est retourné comme chaîne de caractères.
Attend les arguments suivants:
[Argument] |
(facultatif) Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable, ou de la valeur retournée par une autre fonction. Si la mention de l'argument manque, la fonction s'applique au contenu du nœud actuel par exemple au contenu d'un élément. |
Retourne la chaîne de caractères recherchée.
<xsl:template match="tension"> <xsl:value-of select="string()" /><b><xsl:text> volts</xsl:text></b> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé tension. Le modèle sort la valeur de l'élément, en ayant pourtant transformé la valeur numérique du contenu en une chaîne de caractères . Pour le faire, la fonction code>string() est appliquée dans l'attribut select de l'instruction xsl:value-of. Étant donné qu'aucun argument n'est transmis à la fonction string(), elle se réfère à la valeur de l'élément tension actuel.
|
|
string-length() (rechercher le nombre de signes d'une chaîne de caractères)Recherche la longueur d'une chaîne de caractères.
Attend les arguments suivants:
[chaîne de caractères] |
(facultatif) chaîne de caractères dont la longueur doit être recherchée. Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable, ou de la valeur retournée par une autre fonction. Au cas où l'argument n'est pas une chaîne de caractères mais par exemple un nombre, il sera d'abord transformé en interne en une chaîne de caractères avec la fonction string(). Si la mention de l'argument manque, la fonction s'applique au contenu du nœud actuel par exemple au contenu d'un élément. |
Retourne le nombre de caractères en retour.
<xsl:template match="communication">
<xsl:choose>
<xsl:when test="string-length() < 20">
<p><b>Erreur: Communiqué trop bref!</b></p>
</xsl:when>
<xsl:otherwise>
<p><xsl:value-of select="." /></p>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
|
L'exemple définit un modèle pour un élément XML nommé communication. Le contenu de cet élément ne doit être pris dans l'arbre de transformation que s'il comporte au moins 20 caractères. Pour ce faire, un embranchement logique est réalisé avec xsl:choose. Il est demandé dans l'embranchement xls:when si le contenu de l'élément est plus petit que 20 caractères. Pour cela, la fonction string-length() est appliquée. Étant donné qu'aucun argument n'a été transmis, la fonction se réfère d'emblée au contenu de l'élément actuel. Si moins de 20 caractères sont trouvés un message d'erreur sera écrit dans la sortie. Dans le cas contraire (xsl:otherwise) le contenu de communication est écrit dans l'arbre de transformation.
|
|
substring() (extraire une sous-chaîne d'une chaîne de caractères)Extrait une sous-chaîne d'un nombre de caractères au choix d'une chaîne de caractères, à partir d'une certaine position.
Attend les arguments suivants:
[chaîne de caractères] |
chaîne de caractères dont une partie doit être extraite. Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable. Au cas où l'argument n'est pas une chaîne de caractères mais par exemple un nombre, il sera d'abord transformé en interne en une chaîne de caractères avec la fonction string(). |
[nombre] |
Position dans la chaîne de caractères, à partir de laquelle l'extraction doit se faire. Si par exemple, l'extraction doit commencer dès le premier caractère, 1 doit être transmis, si elle doit commencer à partir du vingtième caractère, 20 doit être transmis. |
[nombre] |
(facultatif) Nombre des signes devant être extraits. Si l'argument manque, l'extraction se fait jusqu'à la fin de la chaîne de caractères. |
Retourne la sous-chaîne de caractères extraite.
<xsl:template match="lieu"> <tr> <td><xsl:value-of select="substring(.,1,5)" /></td> <td><xsl:value-of select="substring(.,7)" /></td> </tr> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé lieu, dont on suppose qu'il contient des données sous la forme 59100 Roubaix. Le code postal et la ville doivent être séparés lors de la sortie dans l'arbre de transformation pour être portés dans deux cellules de tableau séparées. Pour cela la fonction substring() est affectée pour chacune à l'attribut select de l'instruction xsl:value-of. Elle extrait pour le premier des deux appels pour le contenu de l'élément actuel qui est recherché avec ., les cinq premiers signes à savoir le code postal, et pour le deuxième appel les signes à partir de la 7ème position jusqu'à la fin de la mention du lieu, à savoir le nom du lieu sans code postal.
|
|
substring-after() (rechercher une sous-chaîne à partir d'une certaine position dans une chaîne de caractères)Vérifie si une chaîne de caractères contient une certaine sous-chaîne de caractères. Si c'est le cas, la chaîne de caractères qui reste après que la sous-chaîne ait été trouvée pour la première fois est retournée. Ceci est par exemple pratique pour extraire des valeurs dans des données existant sous la forme nom_variable=valeur affectee . C'est similaire à la façon de travailler de la fonction substring-before(), qui peut extraire de ces mêmes données le nom de la variable.
Attend les arguments suivants:
[chaîne de caractères] |
Chaîne de caractères dont une partie doit être extraite. Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable. Au cas où l'argument n'et pas une chaîne de caractères mais par exemple un nombre, il sera d'abord transformé en interne en une chaîne de caractères avec la fonction string(). |
[sous-chaîne de caractères] |
chaîne de caractères qui doit se trouver dans la première chaîne de caractères mentionnée auparavant. Il peut s'agir aussi d'un seul signe. |
Retourne la chaîne de caractères restante située derrière la sous-chaîne de caractères au cas où elle a été trouvée. Dans le cas contraire, c'est une chaîne de caractères vide qui est retournée. La fonction contraire substring-before() retourne en conséquence la partie de la chaîne de caractères située avant la sous-chaîne de caractères.
<xsl:template match="element_config"> <th><xsl:value-of select="substring-before(current(),'=')" /></th> <td><xsl:value-of select="substring-after(current(),'=')" /></td> </xsl:template> |
Dans l'exemple il est supposé d'un élément XML nommé element_config qu'il contient séparées par le signe égal les désignations et les valeurs, par exemple largeur=475m. Dans la définition de modèle pour cet élément, la partie avant le signe égal doit être prise dans une cellule d'entête de tableau HTML et la partie derrière le signe égal dans une cellule de données du tableau. Pour cela, la fonction substring-before() est affectée dans la première partie à l'attribut select de l'instruction xsl:value-of, dans la deuxième partie, la fonction substring-after() lui est affectée. Dans les deux cas, le contenu de l'élément actuel recherché avec current(). La chaîne de caractères qui est le signal pour extraire la sous-chaîne de caractères avant ou après est le signe égal.
|
|
substring-before() (rechercher une sous-chaîne avant une certaine position dans une chaîne de caractères)C'est la fonction contraire de substring-after(). S'y reporter pour l'exemple.
|
|
sum() (rechercher la somme de valeurs numériques)Recherche la somme totale des valeurs numériques du nœud de sortie. Si des valeurs ne peuvent pas être interprétées comme chiffres, c'est NaN (not a number) qui est trouvé.
Attend les arguments suivants:
[jeu de nœuds] |
Un jeu de nœuds pour lequel la somme de ses valeurs interprétée en nombres doit être recherchée. Pour le bien, le jeu de nœuds contient plusieurs nœuds avec des valeurs qui peuvent être interprétées comme des nombres et dont la somme est intéressante pour une raison ou pour une autre. |
Retourne la somme des valeurs recherchées.
<xsl:template match="rectangle"> <p> <b><xsl:value-of select="name()" /> pourtour:</b><xsl:value-of select="sum(@*)" />cm </p> </xsl:template> |
L'exemple montre un modèle pour un élément XML nommé rectangle, qui pourrait être noté à peut près ainsi:
<rectangle gauche="12" droite="12" haut="20" bas="20" />
Dans la transcription HTML, le périmètre du rectangle est simplement sorti dans un paragraphe de texte. Pour cela, la somme des attributs de l'élément rectangle est recherchée avec select="sum(@*)" . Pour l'exemple XML noté ci-avant on obtiendrait donc 64 étant donné que c'est la somme des valeurs d'attribut 12, 12, 20 et 20. L'argument @*, qui est transmis dans l'exemple à la fonction sum(), figure pour "tous les attributs de l'élément".
|
|
system-property() (rechercher des propriétés système)Recherche des informations sur le processeur XSLT utilisé.
Attend les arguments suivants:
[chaîne de caractères] |
Une propriété du processeur XSLT. Les mentions suivantes doivent être soutenues par tous les processeurs XSLT: 'xsl:version' (version du standard XSLT qui est interprété par le processeur), 'xsl:vendor' (fabricant du logiciel du processeur) et 'xsl:vendor-url' (URI du fabricant du logiciel du processeur). |
Retourne la valeur recherchée.
<xsl:template match="infossupplementaires">
<p><b><xsl:text>Version XSL: </xsl:text></b>
<xsl:value-of select="system-property('xsl:version')" /></p>
<p><b><xsl:text>fabricant du processeur: </xsl:text></b>
<xsl:value-of select="system-property('xsl:vendor')" /></p>
<p><b><xsl:text>URI du fabricant du processeur: </xsl:text></b>
<xsl:value-of select="system-property('xsl:vendor-url')" /></p>
</xsl:template>
|
L'exemple montre comment un élément XML qui pourrait avoir été défini comme élément vide dans les données XML peut être utilisé comme indicateur pour, dans une transformation XSLT, mettre certaines données à l'endroit correspondant. Dans l'exemple. on suppose un élément XML nommé infossupplementaires qui a une telle fonction. Car dans la définition de modèle pour cet élément, ce n'est pas son contenu qui est sorti, mais certaines propriétés du processeur XSLT utilisé qui sont recherchées avec la fonction system-property() pour être prises dans l'arbre de transformation HTML. Pour cela sont transmis à chaque fois à l'attribut select de l'instruction xsl:value-of des appels de la fonction system-property().
|
|
translate() (rechercher et remplacer des signes dans une chaîne de caractères)Remplace des caractères distincts d'une chaîne de caractères par d'autres caractères.
Attend les arguments suivants:
[chaîne de caractères] |
Chaîne de caractères dans laquelle il faut rechercher et remplacer. Il peut s'agir par exemple du contenu d'un élément ou de la valeur d'une variable. Au cas où l'argument n'et pas une chaîne de caractères mais par exemple un nombre, il sera d'abord transformé en interne en une chaîne de caractères avec la fonction string(). |
[caractères] |
Un ou plusieurs caractères qui doivent être remplacés. |
[caractères] |
Un ou plusieurs caractères par lesquels les caractères mentionnés auparavant doivent être remplacés. Des mentions possibles sont par exemple ',' ou bien ']['. Cet argument doit être transmis mais peut aussi avoir un contenu vide (''). Alors, les caractères mentionnés dans le deuxième argument sont remplacés par rien, donc effacés. |
Retourne la chaîne de caractères traitée.
<xsl:template match="lieu"> <b> <xsl:value-of select="translate(current(),'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ')" /> </b> </xsl:template> |
L'exemple définit un modèle pour un élément XML nommé lieu. Le contenu de l'élément est sorti dans l'arbre de transformation, pourtant toutes les minuscules sont ici transformées en majuscules. À cet effet, la fonction translate() est affectée à l'attribut select de l'instruction xsl:value-of. Celle-ci détermine pour le contenu de l'élément actuel, recherché avec current() que les minuscules de a à z soient remplacées par les majuscules correspondantes.
|
|
true() (créer une valeur booléenne pour "vrai")Affirme une expression.
N'attend pas d'argument
Retourne simplement la valeur logique true.
<xsl:variable name="affichage_mot_passe" select="true()"/>
<xsl:template name="mot_passe">
<xsl:choose>
<xsl:when test="$affichage_mot_passe">
<xsl:value-of select="." />
</xsl:when>
<xsl:otherwise>
<xsl:text>[Mot de passe]</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
|
Dans l'exemple, une variable nommée affichage_mot_passe est définie avec xsl:variable et sa valeur est fixée sur la valeur logique true. Ceci est assuré par la mise en œuvre de la fonction true(), qui est simplement affectée à l'attribut select fixant ainsi la valeur de la variable. De plus, l'exemple montre une définition de modèle pour un élément nommé mot_passe. Dans cette définition de modèle il est demandé dans une construction xsl:choose, comment faire pour l'affichage du mot de passe. Quand la variable $affichage_mot_passe est vraie, la valeur de l'élément mot_passe est sortie avec <xsl:value-of select="." />. Dans le cas contraire, seule la chaîne de caractères [Mot de passe] est sortie.
|
|
unparsed-entity-uri() (rechercher les éléments de la DTD non vérifiés par l'analyseur syntaxique)permet d'accéder aux éléments de la DTD qui n'ont pas été analysés par l'analyseur syntaxique. Cela concerne avant tout les entités pour ressources externes
.
Attend les arguments suivants:
[nom] |
Nom de l'élément non-analysé de la DTD (Entités). |
Retourne l'URI de l'entité mentionnée derrière SYSTEM ou bien PUBLIC. L'adresse correspondante peut alors être mise dans l'arbre de transformation à un endroit approprié.
<!ENTITY logofirme SYSTEM "images/logo.jpg" NDATA JPEG> |
<image source="logofirme" /> |
<xsl:template match="image">
<img src="{unparsed-entity-uri(@source)}" alt="logo de la firme" />
</xsl:template>
|
L'exemple montre une définition d'entité externe dans une DTD. Là est définie une entité nommée logofirme qui se voit affecter un graphique JPEG. La deuxième partie de l'exemple montre comment cette entité est appliquée dans un fichier XML. Un élément XML nommé image a un attribut nommé source, auquel l'entité est affectée. La troisième partie de l'exemple enfin, montre une définition correspondante dans la feuille de style XSL. Y est défini un modèle pour l'élément image, dans lequel la construction XML est transcrite en une construction HTML pour l'affichage d'un graphique. Ici la fonction unparsed-entity-uri() est affectée à l'attribut src de l'élément img. L'attribut @source de l'élément image est transmis comme argument à la fonction. La fonction retourne l'URI correspondante telle qu'elle a été définie dans la DTD, à savoir images/logo.jpg.
Veillez aux parenthèses accolades, indispensables quand une fonction XPath est utilisée dans le code de l'arbre de transformation. Plus de détails à ce sujet dans la partie sur la syntaxe XPath.
|
| |
 |
Introduction en JavaScript
|
 |
Syntaxe XPath
|
| SELFHTML/Aides à la navigation XML/DTD Représentation de données XML |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org