XSLT XML:XPath
Un article de WikiTuto.
Sommaire |
Introduction
Comme son nom l'indique, XPath est une spécification fondée sur l'utilisation de chemin d'accès permettant de se déplacer au sein du document XML. Dans ce but, un certain nombre de fonctions ont été définies. Elles permettent de traiter les chaînes de caractères, les booléens et les nombres.
Le XPath établit un arbre de noeuds correspondant au document XML. Les types de noeuds peuvent être différents : nœud d'élément, nœud d'attribut et nœud de texte. En vue d'une utilisation plus aisée, le XPath comprend un mécanisme qui associe à tous ces types une chaîne de caractères.
La syntaxe de base du XPath est fondée sur l'utilisation d'expressions. Une expression peut s'appliquer à quatre types d'objets :
- un ensemble non ordonné de noeuds ;
- une valeur booléenne (vrai ou faux) ;
- un nombre en virgule flottante ;
- une chaîne de caractères.
Chaque évaluation d'expression dépend du contexte courant. Une des expressions les plus importantes dans le standard XPath est le chemin de localisation. Cette expression sélectionne un ensemble de nœuds à partir d'un nœud contextuel.
Chemin de localisation
Introduction
Un chemin de localisation peut être de type absolu ou relatif.
- Dans le cas où il est de type absolu, il commence toujours par le signe / indiquant la racine du document XML ;
- Dans le cas où il est de type relatif, le nœud de départ est le nœud contextuel courant.
La syntaxe de composition d'un chemin de localisation peut être de type abrégé ou non abrégé. Toute syntaxe non abrégée ne trouve pas forcément d'équivalence en syntaxe abrégée.
Un chemin de localisation est composé de trois parties :
- un axe, définissant le sens de la relation entre le nœud courant et le jeu de nœuds à localiser;
- un nœud spécifiant le type de nœud à localiser;
- 0 à n prédicats permettant d'affiner la recherche sur le jeu de nœuds à récupérer.
Par exemple, dans le chemin child::section[position()=1], child est le nom de l'axe, section le type de nœud à localiser (élément ou attribut) et [position()=1] est un prédicat. Les doubles :: sont obligatoires.
La syntaxe d'une localisation s'analyse de gauche à droite. Dans notre cas, on cherche dans le nœud courant, un nœud section qui est le premier nœud de son type.
Axes
child : contient les enfants directs du nœud contextuel.
descendant : contient les descendants du nœud contextuel. Un descendant peut être un enfant, un petit-enfant...
parent : contient le parent du nœud contextuel, s'il y en a un.
ancestor : contient les ancêtres du nœud contextuel. Cela comprend son père, le père de son père... Cet axe contient toujours le nœud racine, excepté dans le cas où le nœud contextuel serait lui-même le nœud racine.
following-sibling : contient tous les nœuds cibles du nœud contextuel. Dans le cas où ce nœud est un attribut ou un espace de noms, la cible suivante est vide.
preceding-sibling : contient tous les prédécesseurs du nœud contextuel ; si le nœud contextuel est un attribut ou un espace de noms, la cible précédente est vide.
following : contient tous les nœuds du même nom que le nœud contextuel situés après le nœud contextuel dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms.
preceding : contient tous les nœuds du même nom que le nœud contextuel situés avant lui dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms.
attribute : contient les attributs du nœud contextuel ; l'axe est vide quand le nœud n'est pas un élément.
namespace : contient tous les nœuds des espaces de noms du nœud contextuel ; l'axe est vide quand le nœud contextuel n'est pas un élément.
self : contient seulement le nœud contextuel.
descendant-or-self : contient le nœud contextuel et ses descendants.
ancestor-or-self : contient le nœud contextuel et ses ancêtres. Cet axe contiendra toujours le nœud racine.
Prédicats
Le contenu d'un prédicat est une prédiction. Chaque expression est évaluée et le résultat est un booléen.
Par exemple, section[3] est équivalent à section[position()=3].
Ces deux expressions sont équivalentes : chacune d'entre elles produit un booléen. Dans le premier cas, il n'y a pas de test, on sélectionne simplement le troisième élément, l'expression est obligatoirement vraie. Dans le second cas, un test est effectué par rapport à la position de l'élément section ; lorsque la position sera égale à 3, l'expression sera vraie.
Syntaxe non abrégée
Cette syntaxe va être présentée par plusieurs exemples... Les parties qui dépendent du fichier XML analysé sont écrites de cette manière.
child::para : sélectionne l'élément para enfant du nœud contextuel.
child::* : sélectionne tous les éléments enfants du nœud contextuel.
child::text() : sélectionne tous les nœuds de type texte du nœud contextuel.
child::node() : sélectionne tous les enfants du nœud contextuel, quel que soit leur type.
attribute::name : sélectionne tous les attributs name du nœud contextuel.
attribute::* : sélectionne tous les attributs du nœud contextuel.
descendant::para : sélectionne tous les descendants para du nœud contextuel.
ancestor::div : sélectionne tous les ancêtres div du nœud contextuel.
ancestor-or-self::div : sélectionne tous les ancêtres div du nœud contextuel et le nœud contextuel lui-même si c'est un div.
descendant-or-self::para : sélectionne tous les descendants para du nœud contextuel et le nœud contextuel lui-même si c'est un para.
self::para : sélectionne le nœud contextuel si c'est un élément para, et rien dans le cas contraire.
child::chapitre/descendant::para : sélectionne les descendants para de l'élément chapitre enfant du nœud contextuel.
child::*/child::para : sélectionne tous les petits-enfants para du nœud contextuel.
/child:: : sélectionne l'élément racine du document.
/descendant::para : sélectionne tous les éléments para descendants du document contenant le nœud contextuel.
/descendant::olist/child::item : sélectionne tous les éléments item qui ont un parent olist et qui sont dans le même document que le nœud contextuel.
child::para[position()=1] : sélectionne le premier enfant para du nœud contextuel.
child::para[position()=last()] : sélectionne le dernier enfant para du nœud contextuel.
child::para[position()=last()-1] : sélectionne l'avant-dernier enfant para du nœud contextuel.
child::para[position()1] : sélectionne tous les enfants para du nœud contextuel autres que le premier.
following-sibling::para[position()=1] : sélectionne le prochain chapitre cible du nœud contextuel.
On pourrait continuer encore longtemps cette liste d'exemples. Cette syntaxe non-abrégée permet beaucoup de raffinement. child::*[self::chapitre or self::sstitre][position()=last()] permet ainsi de sélectionner le dernier enfant chapitre ou sstitre du nœud contextuel.
Syntaxe abrégée
Cette syntaxe recoupe en fait la "syntaxe de base" vue plus haut. Elle permet d'obtenir des expressions du type para[@type="avertissement"][5], qui sélectionne le cinquième enfant de l'élément para, parmi ceux qui ont un attribut type ayant la valeur avertissement.
Fonctions de base
Généralités
De nombreuses fonctions peuvent être utilisées. Ces fonctions concernent quatre catégories d'objets : nœuds, chaînes de caractères, booléens, nombres. Chaque fonction peut avoir zéro ou plusieurs arguments. Dans les descriptions suivantes, lorsqu'un élément est suivi du caractère ?,cela signifie qu'il est optionnel. Cette liste est loin d'être exhaustive. Le chapitre suivant présente les fonctions XPath de manière plus complète.
Manipulation de nœuds
- Fonctions retournant un nombre :
- last() : retourne un nombre égal à l'index du dernier nœud dans le contexte courant.
- position() : retourne un nombre égal à la position du nœud dans le contexte courant.
- Fonction retournant un jeu de nœuds : id(objet), permet de sélectionner les éléments par leur identifiant.
Manipulation de chaînes de caractères
Beaucoup de fonctions existent. Citons pour mémoire notamment :
- string(noeud?) : cette fonction convertit un objet en chaîne de caractères selon les règles suivantes :
- un ensemble de nœuds est converti en chaîne de caractères en retournant la valeur textuelle du premier nœud de l'ensemble dans l'ordre du document. Si l'ensemble des nœuds est vide, une chaîne vide est retournée.
- un nombre est converti en chaîne suivant des règles dépendant de sa nature (NaN, nombre entier, non-entier, zéro...).
- la valeur booléenne false est convertie en chaîne de caractères "false", de même pour la valeur booléenne true.
Cette fonction n'a pas pour objet de convertir des nombres en chaînes de caractères pour les présenter aux utilisateurs ; il existe des fonctions de transformations XSLT pour ce faire (format-number et xsl:number)
- concat(chaine1, chaine2, chaine*) : retourne une chaîne résultant de la compilation des arguments
- string-length(chaine?) : cette fonction retourne le nombre de caractères de la chaîne. Dans le cas où l'argument est omis, la valeur retournée est égale à la longueur de la valeur textuelle du nœud courant
Manipulation de booléens
Outre la fonction logique not(), ainsi que les fonctions true() et false(), une fonction utile est lang(chaine). Elle teste l'argument chaine par rapport à l'attribut xml:lang du nœud contextuel ou de son plus proche ancêtre dans le cas où le nœud contextuel ne contient pas d'attribut de ce type. La fonction retourne true si l'argument est bien la langue utilisée ou si la langue utilisée est un sous-langage de l'argument (par exemple, en//us). Sinon elle retourne false.
Manipulation de nombres
Voici quelques fonctions de manipulations de nombres :
- floor(nombre) : retourne le plus grand entier inférieur à l'argument passé à la fonction.
- ceiling(nombre) : retourne le plus petit entier supérieur à l'argument passé à la fonction.
- round(nombre) : retourne l'entier le plus proche de l'argument passé à la fonction.
