XPath version 1.

0
Recommandation 16 Novembre 1999

XML Path Language

Sadok Ben Yahia

Faculté des Sciences de Tunis

Sadok.benyahia@fst.rnu.tn
 Objectifs

 Spécifier un mini langage de requête pour interroger des

documents XML et sélectionner des fragments

 Fournir une syntaxe et une sémantique communes pour :

 XSL Transformation Language (XSLT)

 Feuilles de style

 XML Pointers (XPointer)

 Liens hypertextes

2
 Introduction

 Adresser et sélectionner des sections d'un document XML

 Éléments et hiérarchie

 Noms et valeurs d'attributs

 Contenu textuel

 Fonctionnalités de base pour manipuler :

 Chaînes de caractères

 Nombres et booléens

3
 Expression

 Une expression XPath active un objet de type:

 Collection non-ordonnée de nœuds uniques

node-set

 Booléen

true ou false

 Nombre à virgule (int ou float)

 Chaîne de caractères Unicode

4
 Chemin de localisation

 2 syntaxes
 Longue qui couvre tout le langage
 Courte/Abrégée pour les cas les plus usuels
 Attention : quelques différences de comportement entre les deux
représentations !

 2 types de chemin
 Absolu (utilisation des ID par exemple)
 Relatif
 Suivre des axes :
– Nœud actuel : self
– Nœuds enfants / descendants : child, descendant,
descendant-or-self
– Nœuds parents / ancêtres : parent, ancestor, ancestor-or-self
– Nœuds frères : preceding-sibling, following-sibling
– Nœuds avant / après : preceding, following

5
 Exemple

 Nœud contextuel : garage

 1. child::voiture  /voiture
 2. descendant-or-self::modele  //modele

 Nœud contextuel : modele(206)

 3. following::*
 4. preceding-sibling::*
<garage>
garage
<voiture>
<marque>Peugeot</marque>
1 13
<modele>206</modele> voiture voiture
</voiture>
<voiture> 4 2 3 23
<marque>Renault</marque> marque modele marque modele

<modele>Clio</modele>
</voiture> Peugeot 206 Renault Clio
</garage>
6
 Les axes

 Direction de la recherche à partir d’un nœud contextuel

 En général, 3 parties par étape

 Un axe : suivant, précédant, parent, enfants, …
 Un test : type d'élément cherché
 Un élément particulier
 Les nœuds éléments : *
 Les nœuds texte : text()
 Les nœuds : node()
 Les commentaires : comment()
 Les instructions de traitement : processing-instruction()
 Un prédicat : renvoie une valeur booléenne (vrai ou faux)

axis::node-test[prédicat]

7
Les axes - Illustration

contexte

8
 Axe : les enfants

child::

 Sélectionne les enfants immédiats du nœud/élément

contextuel/courant
/*  /child::*
child:garage/child::voiture/child::*
 garage/voiture/* garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

9
Axe : les enfants

child

context

10
 Axe : les descendants

descendant::

 Sélectionne la descendance du nœud/élément contextuel

child::garage/descendant::*

descendant-or-self::

 Idem mais sélectionne également le nœud courant

child::garage/descendant-or-self::*  //*
garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

11
Axe : les descendants

descendant

context

12
Axe : les descendants

descendant-or-self

context

13
 Axe : lui-même

self::

 Réfère au nœud courant (le contexte)

 Rarement utilisé avec les XPointer mais plus utiles dans XSLT
 Utile pour tester le nœud courant
self::marque

 Sans test sur le nœud, peut s'abréger par le point .

.  self::node()

14
 Axe : le parent

parent::

 Sélectionne le parent immédiat du nœud courant

/descendant-or-self::voiture/parent::*

 Sans test sur le parent, peut-être abrégé par ..

parent  ..
/descendant-or-self::modele/parent::*  //modele/..
 Sélectionne tous les éléments qui ont un fils de type voiture
garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio 15

 Axe : les ancêtres

ancestor::

 Sélectionne tous les nœuds/éléments qui contiennent le nœud

courant (parent, grand-parent, etc.)
descendant-or-self::modele/ancestor::*[position()=1]
 Sélectionne le parent de chaque descendant de type modele
descendant-or-self::modele/ancestor::*[position()=2]
 Sélectionne le grand-parent pour chacun des descendants de type
modele's

ancestor-or-self::

 Sélectionne le nœud courant et tous les éléments qui contiennent le

nœud courant (parent, grand-parent, etc.)
child::garage/child::voiture/ancestor-or-self::*
garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio 16

Axes : lui-même, parent et ancêtres
ancestor-or-self
ancestor

parent

self
context

17
 Axe : les nœuds précédant

preceding::

 Sélectionne les nœuds qui précédent le nœud courant

descendant-or-self::voiture[position()=2]/preceding::*
 Sélectionne les éléments voiture et les sous-éléments précédent

garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

18
 Axe : les nœuds suivants

following::

 Sélectionne les nœuds qui suivent le nœud courant

descendant::voiture[position()=1]/following::*
 sélectionne les éléments voitures suivants

garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

19
 Axe : les nœuds suivant
sauf
sauflala
descendance
descendancedu
nœud
du
contextuel following
nœud contextuel

context

20
Axe : les nœuds précédant
sauf
saufles
lesparents
parentset
et
ancêtres du nœud
ancêtres du nœud
preceding contextuel
contextuel

context

21
 Axe : les frères précédant

preceding-sibling::

 Sélectionne les nœuds qui précédent le nœud courant et

partagent le même parent
 Sélectionne les frères précédant le nœud courant
 Les aînés
descendant-or-self::voiture[position()=2]/preceding-sibling::*
 sélectionne l’élément voiture en position 1

garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

22
 Axe : les frères suivant

following-sibling::

 Sélectionne les nœuds qui suivent le nœud courant et

partagent le même parent
 Sélectionne les frères suivant le nœud courant
 Les cadets
descendant::voiture[position()=1]/following-sibling::*
 sélectionne les éléments voitures suivants

garage

voiture voiture

marque modele marque modele

Peugeot 206 Renault Clio

23
 Axes : frères précédant

preceding-sibling

context

24
Axes : frères suivant

following-sibling

context

25
 Axe : les attributs

attributes::
 Sélectionne les attributs du nœud courant
descendant-or-self::voiture/attribute::id
 //voiture/@id
 Sélectionne tous les éléments voiture avec un
attribut id

descendant-or-self::voiture/attribute::id ="V1"
 //voiture/@id="V1"
 Sélectionne tous les éléments voiture avec un
attribut id ayant comme valeur v1

//voiture/@*
 Sélectionne tous les éléments VOITURE ayant des
attributs

26
 Node-test : les tests (1)

 Tous les éléments

node()
 Tout type de nœud (texte, commentaire, …)

descendant::garage/child::*[position()=2]
=> Élément voiture en 2ème position
descendant-or-self::modele[position()=1]/child::node()
=> 206

27
 Node-test : les tests (2)

text()
 Le contenu textuel d'un élément
descendant::modele[position()=1]/text()

comment()
 Pour les commentaires
descendant-or-self::comment()

processing-instruction()
 Instructions de traitement (PI)
/descendant::processing-instruction(xml-stylesheet)
/descendant::processing-instruction(php)

28
 Un dernier mot sur les versions
abrégées

 Une petite subtilité pratique

//voiture[modele]
 Sélectionne les voitures qui possèdent un élément marque
//voiture[modele='206']
 Sélectionne les voiture qui possèdent un élément marque dont le
contenu est égal à 206

 Attention, l'évaluation des deux expressions :

//voiture[2][@id='V2']
//voiture[@id='V2'][2]

 Ne donne pas le même résultat !

29
 Récapitulatif

Opérateur Description
element sélectionne tous les éléments element fils du noeud courant (child::element).
* sélectionne tous les éléments fils du noeud courant.
/ représente l'élément racine.

// représente n'importe quel descendant de l'élément racine, donc tous les éléments
(descendant-or-self::node()).
. représente l'élément courant (self::node()).

.. permet de remonter d'un niveau dans l'arborescence du document par rapport à

l'élément courant (parent::node()).
/element sélectionne tous les éléments element sous l'élément racine ().

./element sélectionne tous les éléments element sous l'élément courant

(following::element).

../element sélectionne tous les éléments element sous l'élément parent du noeud courant
(preceding::element).

//element sélectionne tous les éléments element descendants du noeud courant à quelque
niveau de profondeur que ce soit.
@attribut sélectionne tous les attributs attribut du noeud courant (attribute::attribut).
| correspond à un ou.
30
 Les opérateurs

 Les opérateurs booléens :

Opérateur Description

or représente un OU logique.

and représente un ET logique.

not() signifie la négation ou NON logique.

| permet la sélection de plusieurs motifs.

= représente l'égalité.

!= signifie différent de...

< signifie inférieur à...

<= signifie inférieur ou égal à…

> signifie supérieur à...

>= signifie supérieur ou égal à...

31
 Les opérateurs

 Les opérateurs de calculs

Opérateur Description
+ effectue une addition.
- effectue une soustraction.
* Effectue une multiplication
div effectue une division.
mod effectue un modulo.

logitheque/categorie[position()=1]/node()[(position() mod 2)= 0]

32
 Les opérateurs

Prédicat Description

element sélectionne tous les éléments element fils du noeud courant.

element[n] sélectionne le nième élément element dans le noeud courant.

sélectionne dans le noeud courant, l'élément element qui a comme

element[elt]
élément fils elt.

sélectionne dans le noeud courant, l'élément ayant pour fils un noeud elt
[elt="valeur"]
qui a une valeur égale à valeur.

sélectionne dans le noeud courant, l'élément element qui possède un

element[@attribut]
attribut attribut.

sélectionne dans le noeud courant, l'élément dont l'attribut attribut a une

[@attribut='valeur']
valeur égale à valeur.

33
 Manipulation des chaînes de
caractères
 Fonctions classiques de manipulation de chaînes de
caractère
string concat(string, string+)
string substring-before(string, string)
string substring-after(string, string)
string substring(string, number, number?)
number string-length(string?)
string normalize-space(string?)
string translate(string, string, string)

boolean starts-with(string, string)

boolean contains(string, string)

34
 Exemples : chaînes de caractères

concat("13","/","09","/","1999")
"13/09/1999" =
substring-before("13/09/1999","/")
"13" =
substring-after("13/09/1999","09")
"/1999" =
substring("13/09/1999",7,4)
"1999" =

"13" = substring("13/09/1999",0,3)

"CoSMoS 1999" = translate("cosmos 1999","csm","CSM")

false = starts-with("cosmos 1999", "star")

true = starts-with("cosmos 1999", "co")

false = contains("cosmos 1999", "kirk")

true = contains("cosmos 1999", "os")

35
 Conversions

string string(object?)
 le premier nœud d'un node-set
 les nombres, les booléens,

number number(object?)
 chaînes, booléen (true en 1, false en 0)
 node-set d'abord converti en string puis en number

sans argument, c'est le nœud courant qui est converti

36
 Fonctions sur les node-set

 Sur le contexte :  Sur un node-set :

number last() number count(node-set)
number position() number position()
 Attribut ID unique :

node-set id(object)

 Espace de noms : <tei:seg

xmlns:tei="http://...">

string local-name(node-set?) "seg"

string namespace-uri(node-set?) "http://..."
string name(node-set?) "tei:seg"

37
Et maintenant …

A vous de jouer !