X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=xpi%2Fxpi_03.xhtml;fp=xpi%2Fxpi_03.xhtml;h=0000000000000000000000000000000000000000;hb=6ad5a39df30fc67494ecbc37babadbf58a213fda;hp=2e5d601d06e411ec9dffd38752aaa25e03be8d5a;hpb=5ab05e8da9f56a68ede3a05dbce2fccf9f44b715;p=hacks%2FsimpleWebSlides.git diff --git a/xpi/xpi_03.xhtml b/xpi/xpi_03.xhtml deleted file mode 100644 index 2e5d601..0000000 --- a/xpi/xpi_03.xhtml +++ /dev/null @@ -1,440 +0,0 @@ - - - - - XPath (suite) - - - - - - - - - - - - - - - - - - - - -
-

XML et Programmation Internet

-

Cours 3

- kn@lri.fr -
-

Évaluation des prédicats

-
-

Rappels de syntaxe

- - p ::= p or p - | p and p - | not (p) - | count(…), contains(…), position(), … - | chemin XPath - | e1 op e2 - -

On évalue le prédicat et on converti son résultat en valeur de - vérité. Si la valeur vaut vrai, on garde le nœud courant, si elle - vaut faux, on ne le garde pas -

-

XPath connait 4 types de données pour les prédicats :

- -
-
-

Comparaisons (e1 op e2)

-

Les opérateurs de comparaisons sont : =, !=, <, <=, - >, >= .
- La manière de calculer de vérité de e1 op - e2 dépend du typed de e1 - et e2 : -

- -
-
-

Comparaisons des valeurs scalaires

- v1 op v2 -

Si op est != ou =, on applique les règles dans cet ordre:

-
    -
  1. Si v1 (resp. v2) est - un booléen, alors v2 - (resp. v1) est converti en booléen et les deux - booléens sont comparés
    2. -
  2. Sinon si v1 (resp. v2) est - un nombre, alors v2 - (resp. v1) est converti en nombre et les deux - nombres sont comparés
    3. -
  3. Sinon, v1 et v2 sont des - chaines de caractères, on les compares
    4. -
-

Si op est <, <=, > ou - >=, on convertit v1 - et v2 en nombres et on les compare. -

-
-
-

Conversions

-

Conversion en booléen

- -

Conversion en nombre

- -
-
-

Conversions (suite)

-

Conversion en chaine de caractères

- -
- -
-

Appels de fonction

-

Il existe des fonctions prédéfinies (voir la spec XPath)

- -

Si les arguments ne sont pas du bon type, ils sont convertis en - utilisant les règles de conversion

-
-
-

Exemples

-

Dans la suite, on se donne un document de test ayant une - racine ... ]]> et une expression XPath qui - sélectionne la racine si et seulement si le prédicat vaut vrai -

-
-
-

Exemples

- - 1 - 2 - ]]> -
  1. - /child::a[ child::*/child::text() ] - sélectionne la racine (l'ensemble de nœud - renvoyé par child::*/cild::text() est non vide, donc il est converti - en true)

    2. -
  2. - /child::a[ child::*/child::text() = "2" ] - sélectionne la racine (l'ensemble de nœud texte - renvoyé par child::*/child::text() est comparé à "2", et - il existe un élément dans cet ensemble pour lequel le test réussi - )

    3. -
  3. /child::a[ child::*/child::text() != "2" ] - sélectionne la racine (l'ensemble de nœud texte - renvoyé par child::*/child::text() est comparé à "2", et - il existe un élément dans cet ensemble pour lequel le test réussi - )

    4. -
  4. /child::a[ not(child::*/child::text() = "2") ] - ne sélectionne pas la racine (on - prend la négation du deuxième cas ci-dessus) -

    5. - -
-
-
-

Exemples

- - 12 - 23 - ]]> -
    -
  1. - /child::a[ child::*/child::text() > 1.5 ] - sélectionne la racine (l'ensemble de nœud texte - renvoyé par child::*/child::text() est comparé à 1.5, et - il existe un élément dans cet ensemble pour lequel le test réussi - )

    2. -
  2. /child::a[ child::b/child::text() >= child::c/child::text() ] - sélectionne la racine (les deux - ensembles de nœuds sont convertis en ensmbles de nombres, car on - utilise >= et on a bien que 2 >= 2 - )

    3. -
  3. /child::a[ child::b/child::text() = child::c/child::text() ] - sélectionne la racine (les deux - ensembles de nœuds comportent un élément commun)

    4. -
  4. /child::a[ child::b/child::text() != child::c/child::text() ] - sélectionne la racine (les deux - comportent des éléments différents)

    5. -
-
-
-

Exemples

- 1223 ]]> -
    -
  1. - /child::a[ contains(self::*, "22") ] - sélectionne la racine(l'ensemble de - nœud séléctionné par self::*, i.e. la racine est converti - en chaine. Pour ce faire, on colle toutes éléments textes - descendants et on obtient la chaine "1223" qui contient bien "22") -

    2. -
  2. - /child::a[ self::* > 442.38 ] - sélectionne la racine(l'ensemble de - nœud séléctionné par self::*, est converti en chaine puis - en nombre pour comparer 1223 à 442.38) -

    3. - -
  3. - /child::a[ sum(child::*) >= 7.5 ] - sélectionne la racine(la fonction - sum converti la liste de valeurs passée en argument en - liste de nombre et fait la somme de ces derniers) -

    4. -
-
- -
-

Exemples

- 1toto23 ]]> -
    - -
  1. - /child::a[ sum(child::*) >= 7.5 ] - ne sélectionne pas la racine(la fonction - sum converti la liste de valeurs passée en argument en - liste de nombres, toto n'étant pas un nombre valide, il est - remplacé par NaN. La somme totale fait donc NaN, et une - comparaison avec NaN renvoie toujours faux) -

    2. -
-
-
-

Prédicat imbriqués

-

On peut imbriquer des prédicats de manière arbitraire:

- Q1 ≡ /child::a[ child::b[ count(descendant::c) > 4 ] ] -

Quelle différence avec :

- Q2 ≡ /child::a[ count(child::b/descendant::c) > 4 ] -

Il suffit de considérer le document : - - - - - ]]> - Q1 ne séléctionne rien car il n'y a - aucun b ayant plus de 4 - descendants c.
Q2 séléctionne - la racine car le nombre de descendants c de - nœuds b est plus grand que 4. -

-
-
-

position() et last()

-

La fonction position() renvoie la position du nœud au - sein de l'ensemble de résultats en cours de filtrage. Last - renvoie le nombre d'éléments dans cet ensemble (ou l'indice du - dernier élément). Les indices commencent à 1 :

- - AA - BB - CC - ]]> - - /child::a/child::b[ position() = 2 ] (renvoie BB]]>) - /child::a/child::b[ position() = last() ] (renvoie CC]]>) - /child::a/child::b[ position() mod 2 = 1 ] (renvoie AA - CC]]>) - -
-

Axes complexes

-
-

L'axe attribute::

-

Permet d'accéder aux attributs d'un élément.Attention, les - attributs ne font pas partie des fils ni des descendants!

- - AA - BB - CC - ]]> - - /descendant::b[ attribute::* = "y" ] (renvoie BB]]>) - /descendant::b[ attribute::id = "y" ] (ne renvoie rien) - -
-
-

Les axes preceding:: et following::

-

L'axe preceding:: selectionne tous les nœuds arrivant - avant le nœud courant et qui ne sont pas des ancetres de ce - dernier.

-

L'axe following:: selectionne tous les nœuds arrivant - après le nœud courant et qui ne sont pas des descendants de ce dernier.

- - - - - - - - - - - - ]]> - - /descendant::m/preceding::* (séléctionne l, i, h, b, c, d, e, f, g) - /descendant::d/following::* (sélectionne h, i, j, k, l, m) - -
-
-

Autres opérateurs

-

On peut donner plusieurs prédicats à un chemin : - - /descendant::a [ descendant::b ][ position () > 4 ][ child::c ] - -Sélectionne l'ensemble des nœuds A1 ayant un - tag a et ayant un descendant b. Filtre - A1 pour ne garder que A2, l'ensemble des - nœuds de A1 étant en position supérieure à - 4. Filtre A2 pour ne - garder que les nœuds ayant un fils c. -

-

On peut prendre l'union de plusieurs chemins :

- - /descendant::a/parent::b | /descendant::c/following-sibling::d - -
-

Syntaxe abrégée

-
-

Abréviations

-

XPath étant très verbeux il existe une syntaxe abrégée pour - les situations les plus courantes :

- -

Exemple :

- //book [ year > 2005 ]/title - - -
- -