Université Abou-Bekr Belkaid – Tlemcen -

Faculté des Sciences

Département Informatique

Données Semi-structurées

2024-2025
 Plan

• 1/ Introduction aux données semi-structurées

• 2/ Le langage XML
• 3/ La Déclaration de Type de Document DTD
• 4/ Le Schéma XML
• 5/ Le langage XPATH
• 6/ Le langage de feuille de style XSL
• 7/ Le langage XSLT.
Mise en forme à l'aide de feuilles
de style XSL
XSLT
 Introduction
• Le XSLT est un langage de haut niveau qui offre à la fois un langage très puissant de
programmation et de manipulation d’éléments XML et un langage de feuille de style.

• XSLT permet de transformer un document XML source en un autre en utilisant de

nombreuses notions dignes d’un langage de haut niveau tel que : variables, paramètres
tests, boucles, fonctions, inclusion d’une feuille de style XSLT dans une autre,
chargement de plusieurs documents XML dans une même feuille de style XSLT,
recherche de balises XML selon de nombreux critères,…etc.
 Introduction
• Le langage de transformation XSLT est utilisé pour transformer un document
XML en divers documents au format XML, HTML, RTF (Rich Text Format) ou
autres format texte. Il permet d’extraire un sous-ensemble de données d’un
document XML, localisé grâce à des expressions XPATH, et de créer de
nouveaux documents avec des données extraites. Cette transformation est faite
grâce à des règles écrites dans un fichier XML nommé feuille de style. Elles
seront ensuite automatiquement appliquées par un navigateur web ou par un
programme spécifique appelé parseur ou processeur XSLT.
 Éléments XSLT
<xsl:stylesheet>
• Cet élément doit être l'élément racine du document XSL, et en tant que tel doit figurer juste après le
prologue. Il contient tous les autres éléments de mise en forme.

<xsl:stylesheet version="1.0"
xmlns:xsl="[Link]
(...)

</xsl:stylesheet>

• version identifie la version de la méthode de sortie (xml 1.0, html 4.01...).

• xmlns indique la version du jeu de caractères à utiliser pour la sortie.
 Éléments XSLT
<xsl:output>
• Cet élément vide, à placer comme premier enfant de <xsl:stylesheet>, permet de
spécifier des options concernant l'arbre de sortie.

<xsl:output method="xml | html | text"

version="nmtoken"
encoding="chaine"
omit-xml-declaration="yes | no"
standalone="yes | no"
doctype-public="chaine"
doctype-system="chaine"
cdata-section-elements="elt"
indent="yes | no"
media-type="chaine" />
 Éléments XSLT
<xsl:output>

• method identifie la méthode de transformation. Dans le cas où elle est égale à text, aucune mise en
forme n'est effectuée.
• version identifie la version de la méthode de sortie (xml 1.0, html 4.01...).
• encoding indique la version du jeu de caractères à utiliser pour la sortie.
• omit-xml-declaration indique au processeur XSLT s'il doit ajouter ou non une déclaration XML.
• standalone indique au processeur XSLT s'il doit créer un arbre de sortie avec ou sans déclaration de
type de document.
• doctype-public indique l'identifiant public utilisé par la DTD associée à la transformation.
• doctype-system indique l'identifiant system utilisé par la DTD associée à la transformation.
• cdata-section-elements indique les éléments dont le contenu doit être traité lors de la transformation
via une section CDATA.
• indent présente la transformation sous forme d'arbre dans le cas où la valeur de cet attribut est égale à
yes.
• media-type indique le type MIME des données résultantes de la transformation.
 Éléments XSLT
<xsl:template>
• définit un modèle à appliquer à un nœud.
<xsl:template name="nommodele"
match="expression XPATH"
mode="modemodele">
…
</xsl:template>
Elle se déclenche :
• soit pour l'élément racine. Elle ne s'exécute donc qu'une seule fois et c'est souvent par une règle sur la racine
qu'est initié le processus de transformation.
• soit à chaque fois que les chemins sur lesquels elle est lancée aboutissent à un l’élément indiqué. Elle pourra
donc être exécutée plusieurs fois en fonction de la structure du document XML à transformer.
• name correspond au nom associé au modèle.
• match indique quel jeu de nœuds sera affecté par le modèle (expression XPATH).
• mode permet à un élément d'avoir plusieurs modèles, chacun générant une sortie différente.
 Éléments XSLT
<xsl:apply-templates>
• déclenche toutes les règles possibles sur les nœuds spécifiés par l'expression XPath. Celle-ci peut définir un
chemin absolu ou un chemin relatif au nœud courant à partir duquel est lancée la règle.

<xsl:apply-templates select="expression XPath" mode="modemodele"/>

• Par exemple
<xsl:apply-templates select="//livre"/>
déclenche des règles sur tous les éléments livre du document XML.

• L'attribut select est facultatif. Une instanciation de règles peut prendre la forme suivante <apply-templates/>
qui est équivalente à <apply-templates select="*"/>. L'expression XPath * désigne tous nœuds éléments fils
du nœud courant.

• La conséquence est que des règles seront lancées pour tous les nœuds fils du nœud courant et que deux
situations se présenteront.
– pour les nœuds auxquels est associée une règle, la règle s'appliquera,
– pour les autres, ce sont les règles par défaut qui s'appliqueront.
 Exemple avec boucle
<biblio>
<livre>
<titre>Les Misérables</titre>
<auteur>Victor Hugo</auteur>
<nb_tomes>3</nb_tomes>
</livre>
<livre>
<titre>L'Assomoir</titre>
<auteur>Émile Zola</auteur>
<nb_tomes>2</nb_tomes>
</livre>
<livre lang="en">
<titre>David Copperfield</titre>
<auteur>Charles Dickens</auteur>
<nb_tomes>3</nb_tomes>
</livre>
</biblio>
 Éléments XSLT
……
<xsl:template match="/">
<html>
<head>
<title>BIBLIOTHEQUE</title>
</head>
<body>
<h1>Bibliothèque</h1>
<h2>Livres</h2>
<ol> <xsl:apply-templates/></ol> ou <xsl:apply-templates select="//livre"/>
</body>
</html>
</xsl:template>
<xsl:template match="livre">
<li><b><xsl:value-of select="titre"/></b></li>
de <b><xsl:value-of select="auteur"/></b> sur
<b> <xsl:value-of select="nb_tomes"/> </b> tomes
</xsl:template>
</xsl:stylesheet>
Appel de templates nommés (Call-template)
….
< xsl : template match=" biblio">
<html><head>< title>Exemple d ’appels nommés< /title>< / head>
<body>
< xsl : apply-templates select=" livre "/ >
</ body></html>
</xsl : template>
< xsl : template match=" titre ">
< xsl : call-template name=" gras "/ ><BR/ >
</xsl : template>
<xsl : template match=" auteur ">
<xsl : call-template name=" gras "/ ><BR/ >
</xsl : template>
<xsl : template name=" gras ">
<B>< xsl : value-of select=" . " / >< /B>
</xsl : template>
</xsl : stylesheet >

 Permet d’afficher les titres et les auteurs en gras.

 Les modes
….
<xsl:template match="/">
<html> <body> <h2>Liste des titres</h2>
<ol> <xsl:apply-templates select="//livre" mode="liste"/> </ol> <hr/>
<h2>Détail des livres</h2>
<table border="1">
<tr><th>Titre</th><th>Auteur</th><th>Nombre de tomes</th></tr>
<xsl:apply-templates select="//livre" mode="detail"/>
</table> </body> </html>
</xsl:template>
<xsl:template match="livre" mode="detail">
<tr><td><xsl:value-of select="titre"/></td>
<td><xsl:value-of select="auteur"/></td>
<td><xsl:value-of select="nb_tomes"/></td></tr>
</xsl:template>
<xsl:template match="livre" mode="liste">
<li> <xsl:value-of select="titre"/></li>
</xsl:template>
</xsl:stylesheet>
 Éléments XSLT
Conditions de test

• <xsl:if> permet la fragmentation du modèle dans certaines

conditions.
• Il est possible de tester la présence d'un attribut, d'un élément, de
savoir si un élément est bien le fils d'un autre, de tester les valeurs des
éléments et attributs.

<xsl:if test="condition">action</xsl:if>

– test prend la valeur 1 ou 0 suivant le résultat de la condition

(vrai ou faux).
– action correspond à l'action devant être effectuée (texte à
afficher, second test, gestion de chaîne...).
 Éléments XSLT
Conditions de test
<ul>
<xsl:for-each select="livre">
<li>
<xsl:value-of select="auteur" /><br />
<xsl:value-of select="titre" />.
<xsl:if test="@langue='français'">
Ce livre est en français.
</xsl:if>
</li>
</xsl:for-each>
</ul>

 Si l'attribut langue de l'élément livre vaut francais, le processeur ajoutera au fichier

de sortie la phrase "Ce livre est en français". Il ne se passe rien si ce n'est pas le cas.
 Éléments XSLT
Conditions de test
• <xsl:choose> permet de définir une liste de choix et d'affecter à chaque choix une
transformation différente. Chaque choix est défini par un élément <xsl:when> et
un traitement par défaut peut être spécifié grâce à l'élément <xsl:otherwise>.
<ul>
<xsl:for-each select="livre">
<li><xsl:value-of select="auteur"/><br /><xsl:value-of select="titre"/>
<xsl:choose>
<xsl:when test="@langue='fr'">Ce livre est en français.</xsl:when>
<xsl:when test="@langue=‘en'">Ce livre est en anglais.</xsl:when>
<xsl:otherwise>Ce livre est dans une langue non répertoriée.
</xsl:otherwise>
</xsl:choose>
</li>
</xsl:for-each>
</ul>
 Éléments XSLT
Gestion des boucles

• <xsl:for-each> crée une boucle dans laquelle sont appliquées des

transformations.

<xsl:for-each select="Expression XPATH">

…..
</xsl:for-each>

select correspond au jeu de nœuds devant être parcouru par la boucle.

<ul>
<xsl:for-each select="item">
<li><xsl:value-of select="." /></li>
</xsl:for-each>
</ul>
 Éléments XSLT
Gestion des boucles

• <xsl:sort> permet d'effectuer un tri sur un jeu de nœuds. Il doit être placé
soit dans un élément <xsl:for-each> soit dans un élément <xsl:apply-
templates>.
• C'est un élément vide qui peut être appelé plusieurs fois pour effectuer un tri
multicritères.
• Chaque appel à cet élément provoque un tri sur un champ spécifique, dans
un ordre prédéfini.

<xsl:sort select="noeud"
data-type="text | number | elt"
order="ascending | descending"
lang="nmtoken"
case-order="upper-first | lower-first" />
 Éléments XSLT
Gestion des boucles

<xsl:sort>
• select permet de spécifier un nœud comme clé de tri.
• data-type correspond au type des données à trier. Dans le cas où le type est number,
les données sont converties puis triés.
• order correspond à l'ordre de tri. Cet attribut vaut ascending ou descending.
• lang spécifie quel jeu de caractères utiliser pour le tri ; par défaut, il est déterminé en
fonction des paramètres système.
• case-order indique si le tri a lieu sur les majuscules ou minuscules en premier.
 Éléments XSLT
Gestion des boucles
<xsl:sort>
<ul>
<xsl:for-each select="livre">
<xsl:sort select="auteur" order="descending"/>
<li><xsl:value-of select="auteur" /><br />
<xsl:value-of select="titre" />
</li>
</xsl:for-each>
</ul>

 La liste des livres est classée dans l'ordre alphabétique décroissant des
noms d'auteur.
 Éléments XSLT
Gestion des boucles

• <xsl:number> Cet élément permet d’insérer un nombre formaté pouvant servir de

compteur.

<xsl:number level="single | multiple | any"

count="nœud"
from="nœud"
value="expression XPath"
format="chaine"
lang="nmtoken"
grouping-separator="car"
grouping-size="nombre" />
 Éléments XSLT
Gestion des boucles
<xsl:number>

• level indique quels niveaux doivent être sélectionnés pour le comptage : single
permet de ne compter que la position du nœud par rapport à ses frères ; multiple
permet de compter la position du nœud par rapport à ses ancêtres (par exemple de
la forme 1.3.4) ; enfin any renvoie la position du nœud par rapport à l'ensemble des
nœuds de même nom dans tout le document.
• count indique quels nœuds doivent être comptés dans les niveaux sélectionnés ;
dans le cas où cet attribut n'est pas défini, les nœuds comptés sont ceux ayant le
même type que celui du nœud courant.
• from identifie le nœud à partir duquel le comptage commence.
• value indique l'expression correspondant à la valeur du compteur ; si cet attribut
n'est pas défini, le nombre inséré correspond à la position du nœud (position()).
 Éléments XSLT
Gestion des boucles
<xsl:number>
• format spécifie le format de l'affichage du nombre ; cela peut être un chiffre, un
caractère (a-z, A-Z) et comprendre un caractère de séparation tel que le point (.), le
trait d'union (-) ou autre. Les formats possibles sont "1", "01", "a", "A", "i", "I".
• lang spécifie le jeu de caractères à utiliser ; par défaut, il est déterminé en fonction
des paramètres du système.
• grouping-separator identifie le caractère permettant de définir la séparation entre
les centaines et les milliers.
• grouping-size spécifie le nombre de caractères formant un groupe de chiffres dans
un nombre long ; le plus souvent la valeur de cet attribut est 3. Ce dernier attribut
fonctionne avec...
• ...grouping-separator ; si l'un des deux manque, ils sont ignorés.
 Éléments XSLT
Gestion des boucles
<xsl:number>
Exemple:

<book>
<chapter>
<section>1
<section>2</section><section>3</section></section>
<section>4<section>5</section><section>6</section></section>
</chapter>
<chapter>
<section>7<section>8</section><section>9</section></section>
<section>10<section>11</section><section>12</section></section>
</chapter>
</book>
 Éléments XSLT
<xsl:number>
Exemple de single:
<xsl:template match="/">
<html>
<body>
<xsl:for-each select="//section"
<font color="red"> <b>
<xsl:number level="single" count="section" from="/" format="1/ "/>
</b></font>
<xsl:value-of select="./text()"/> <xsl:text> </xsl:text>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
 Éléments XSLT
<xsl:number>
Exemple de multiple:
<xsl:template match="/">
<html>
<body>
<xsl:for-each select="//section"
<font color="red"> <b>
<xsl:number level="multiple" count="chapter|section" from="/" format="A.1.i/ "/>
</b></font>
<xsl:value-of select="./text()"/> <xsl:text> </xsl:text>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
 Éléments XSLT
<xsl:number>
Exemple de Any:
<xsl:template match="/">
<html>
<body>
<xsl:for-each select="//section"
<font color="red"> <b>
<xsl:number level="any" count="section" from="/" format="1/ "/>
</b></font>
<xsl:value-of select="./text()"/> <xsl:text> </xsl:text>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
 Éléments XSLT
<xsl:number>
Exemple de Any:
<xsl:template match="/">
<html>
<body>
<xsl:for-each select="//section"
<font color="red"> <b>
<xsl:number level="any" count="section" from="chapter" format="1/ "/>
</b></font>
<xsl:value-of select="./text()"/> <xsl:text> </xsl:text>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
 Éléments XSLT

L'élément xsl:number suivant utilise l'attribut from pour limiter la numérotation des éléments
section aux contenus des éléments chapter.