Formation avec Exemple XSLT pas à pas
Formation avec Exemple XSLT pas à pas pdf
...
XSL : Extensible Stylesheet Language
Famille de langages pour définir des transformation et des présentations de documents XML
Trois parties
Xpath
langage pour désigner des informations dans un arbre XML sous la forme de chemins (paths)
XSLT
langage de description de transformations à opérer sur un arbre XML
transcodage d’un document XML vers un autre document XML
XSL Formatting Objects (XSL-FO)
Langage de spécification de formatages (pour construire des formes physiques de présentation)
XPath
Recommandation W3C
Versions
Xpath 1.0 : 16/11/1999
Xpath2.0 : 14/12/2010
Objectif :
localiser des documents / identifier des sous-structures dans ceux-ci
Utilisé par d’autres spécifications XML
XPointer, XQuery, XSLT…
Contexte et éléments XML
La signification d’un élément peut dépendre de son contexte
…
…
Supposons que l’on cherche le titre d’un livre, pas le titre d’une personne
Idée
exploiter le contexte séquentiel et hiérarchique de XML pour spécifier des éléments par leur contexte (i.e. leur position dans la hiérarchie)
exemple : book/title ≠ person/title
Xpath : principe général
Décrire un modèle de chemin dans un arbre XML
expression
Récupérer les nœuds qui répondent à ce chemin en utilisant l’expression
résultat de l’application de l’expression à l’arbre XML
Une expression sera utilisée et appliquée au sein de différentes syntaxes
URL : /getQuery?/book/intro/title
XSL : …
Xpointer :
Link to introductory title
Document/arbre/nœuds Xpath
Dans XML
arbre XML = élément XML
Dans Xpath
arbre XPATH = arbre avec toutes les informations repérables dans un document XML:
noeuds éléments (= nœud XML)
noeud racine (représente tout le doc XML)
noeuds attributs
noeuds textes
noeuds instructions de traitement
noeuds commentaires
(noeuds espaces de nom)
Version XML
blabla
blublu
bloblo
youpi
blibli
... ...
Chemins de localisation
Les expressions identifient des noeuds par leur position dans la hiérarchie
Permet de
monter/descendre dans la hiérarchie de l’arbre XML
aller voir les voisins (frères) d’un noeud
en fait : suivre des axes
Un chemin peut être
relatif
à partir de l’endroit où l’on est
absolu
à partir de la racine
Chemins relatifs
On se place dans le contexte d’un nœud
A partir de là, on explore l’arbre XML, et on garde les nœuds qui vérifient l’expression
Exemple
para (ou child::para) sélectionnera les fils du nœud courant qui ont le nom 'para'
<!– Noeud courant -->
…
… <!– Non sélectionné -->
…
Chemins absolus
Expression identique aux chemins relatifs, mais
tout chemin absolu commence par '/’
signifie qu’on part de l’élément racine
Exemple
Trouver tous les éléments 'para' dans un ’chapter'
/book/chapter/para
…
…
…
…
Chemins à plusieurs étapes
Séparer les étapes par des '/'
Exemple
book/title (version courte)
child::book/child::title (version longue)
depuis le noeud courant, on sélectionne d’abord book, qui devient le contexte courant, puis on sélectionne title
Notion d’étape Xpath
Une étape contient trois composants
Axe :: Filtre [ Prédicat ]
axe
sens de parcours des nœuds
filtre
type des nœuds retenus
prédicats
propriétés satisfaites par les nœuds retenus
on peut enchaîner les prédicats
Exemple
child :: chapter [att1 = "toto"]
Remarques
il existe une syntaxe bavarde (verbose) et une syntaxe raccourcie, plus pratique
possibilité de multiples expressions séparées par ‘|’
équivalent d’un OU
Expression = séquence d’étapes
On part du nœud contexte (ou de la racine)
on évalue l’étape 1
on récupère un ensemble de nœuds
pour chacun de ces nœuds
il devient le nœud contexte
on évalue l’étape 2
on récupère un ensemble de nœuds
- pour chacun de ces nœuds
- ...
... ... ...
Filtres
Filtrage par le type
Éléments
Attributs
Instructions de traitement
Filtrage par le nom
Axe :: Filtre [ Prédicat ]
Filtrage par le type
node()
garde tout nœud
text()
noeud gardé si textuel
comment()
noeud gardé si commentaire
processing-instruction()
noeud gardé si instruction de traitement
Axe :: Filtre [ Prédicat ]
Filtrage par le nom
Nom connu
/book/chapter/note
(= /child::book/child::chapter/child::note)
Nom inconnu
Utiliser le joker '*' pour tout élément simple
A/*/B permet de trouver A/C/B et A/D/B
version longue : child::*
Utilisation de plusieurs astérisques, plusieurs niveaux de correspondance
attention à contrôler ce qui se passe
nombre de niveaux
éléments trouvés
Pour un attribut
nom-attribut
Axe :: Filtre [ Prédicat ]
Quelques exemples
chapter//para (noeud contexte = book)
child::chapter/descendant-or-self::node()/child::para
.//para (noeud contexte = book)
self::node()/descendant-or-self::node()/child::para
../title (noeud contexte = chapter)
parent::node()/child::title
note | /book/title (noeud contexte = 2ème chapter)
./* (noeud contexte = book)
/comment()
.//para/text() (noeud contexte = book)
/descendant::node()/att2
//para/*
Axe :: Filtre [ Prédicat ]
Filtres avec prédicats
Les chemins de localisation ne sont pas forcément assez discriminants
peuvent fournir une liste de noeuds
Qu’on peut filtrer à nouveau avec des prédicats
prédicat indiqué entre crochets '[ ]'
si ce qui est dans le prédicat est Vrai : on garde
Le prédicat le plus simple utilise la fonction position()
para[position() = 1] //1er para
chapter[2] //2eme chapter
Possibilité de combiner les tests avec 'and' et 'or'
//*[ self::chapter and att1="tata" ]
Premier test vrai ou faux ?
Deuxième test vrai ou faux ?
Axe :: Filtre [ Prédicat ]
Tests sur les positions / texte
last()
Récupère le dernier noeud dans la liste
count()
Evalue le nombre d’items dans la liste child::chapter [count(child::para) = 2]
string(…)
Récupére le texte d’un élément en enlevant toutes balises
Axe :: Filtre [ Prédicat ]
Exemples
/book/chapter[att1]
les nœuds chapter qui ont un attribut att1
/book/chapter[att1="tata"]
les nœuds chapter qui ont un attribut att1 valant ‘tata’
/book/chapter/descendant::para()[position()=1]
Le(s) premier(s) nœud(s) de type Text descendants d’un /book/chapter
s’abrège en /book/chapter/descendant::text()[1]
/book/chapter[count(para)=2]
Les nœuds chapter qui ont deux enfants de type para
//chapter[child::note]
Les nœuds chapter qui ont des enfants note
Axe :: Filtre [ Prédicat ]
Prédicat : divers
Pour les booléens
not(), and, or
Pour les numériques
<, >, != (différent)
+, -, *, div (division entière), mod (reste div entière)
number() pour essayer de convertir
autres opérateurs : round(), floor(), ceiling()
Exemples
para [not(position() = 1)]
para [position() = 1 or last()]
//node()[number(att2) mod 2 = 1]
les nœuds avec un attribut att2 impair
Axe :: Filtre [ Prédicat ]
Tests sur les chaînes
Possibilité de tester si les chaînes contiennent des sous-chaînes
hello there
note [contains(text(), "hello")]
hello there
l’expression précédente ne fonctionne pas (note/text() donne "there")
utiliser plutôt note[contains(., "hello")]
'.' est le nœud courant, et on parcourra tous les enfants
Axe :: Filtre [ Prédicat ]
Tests sur les chaînes (2)
starts-with(chaine, motif)
note[starts-with(., "hello")]
string(chaine)
note[contains(.,string("12"))]
string-after(chaine, terminateur)
string-before(chaine, terminateur)
substring(chaine, offset, longueur)
Axe :: Filtre [ Prédicat ]
Tests sur les chaînes (3)
normalize(chaine)
enlève les espaces en trop
translate(chaine, source, replace)
translate(., "+", "plus")
concat(strings)
string-length(string)
Axe :: Filtre [ Prédicat ]
Encore des exemples
/book/chapter/child::para[child::note or text()]
Tout élément para fils de chapter ayant au moins un fils note ou un fils text
/descendant::chapter[attribute::att1 or att2]
Tout élément chapter ayant un attribut att1 ou att2
//*[note]
Tout élément ayant un fils note
* [self::note or self::para] (dans le contexte de chapter)
Tout élément note ou para fils du nœud contexte
Quelques fonctions
S’appliquent sur un ensemble de noeuds
id(liste identificateurs) : récupère les éléments ayant ces identificateurs
nécessité d’avoir DTD / schéma
Ex. id(‘id54’ ‘678’)
count()
compte le nombre de nœuds. Ex. count(//para)
max()
rend la valeur maximale
sum()
rend la somme (les nœuds doivent correspondre à des valeurs numériques, traductibles par number())
distinct-values() (Xpath 2.0)
élimine les doublons
Conclusion sur XPath
Xpath permet de retrouver toutes sortes d’information dans les documents XML
requêtes
transformation : lire une information sous une forme, l’écrire sous une autre forme XSLT
Nous avons vu les grands principes
pour la description systématique de la syntaxe
sites de références
pour plus d’exemples
sites avec tutoriaux
Ce cours : présentation de XPATH 1.0
des améliorations dans XPATH 2.0