Chapitre3 XMLetXSL

Développement Web
Chapitre 3 : XML / XSL

Qu'est-ce qu’XML ?
♦ Le XML ( eXtensible Markup Language ou langage à balises extensible) est un
langage de balises comme le HTML mais il est extensible, évolutif. Cela signifie
que les balises utilisées sont définies librement et non fixées par avance comme
pour le HTML. En XML, les balises ne sont pas prédéfinies et leur nombre n’est
pas fixé.
♦ Le XML ne prend en charge que la structure et le contenu des données et non leur
présentation.
♦ Chaque document XML peut avoir une DTD (Document Type Definition) ou un
schéma associé qui définissent sa structure.
♦ XML n’est pas un remplacement d’HTML :
- XML décrit les données et se focalise sur leur signification et est destiné
uniquement au transport et au stockage des données.
- HTML affiche les données et se focalise sur leur apparence dans un navigateur
web.
♦ Le XML est un langage strict dont l’écriture doit être rigoureuse contrairement à la
syntaxe de HTML qui est devenue trop permissive à cause des navigateurs
récents.
25/12/2023 Prof. Hafida ZROURI 2
Premier exemple en XML
<?xml version="1.0" encoding="UTF-8" ?> La structure d’un document
<annuaire> XML est arborescente.
<personne>
<nom>Zrouri</nom> A chaque balise ouvrante,
<prenom>Mohamed</prenom> correspond une balise
<telephone>0684566695</telephone> fermante (Ex: <annuaire> et
</personne> </annuaire>).
<personne>
<nom>Boularcha</nom> Chaque élément peut être
<prenom>Malika</prenom> vu comme un nœud d’un
<telephone>0612345678</telephone> arbre. annuaire a pour sous-
</personne> élément (pour « enfants »)
… personne. personne a pour
</annuaire> enfants nom, prenom et
telephone.

Structure d’un document XML
Un document XML est constitué :
▪ d’un prologue, qui contient un ensemble d’informations
sur le document
▪ d’un arbre d’éléments qui forme le contenu du document
▪ des commentaires, dont la présence est facultative, qui
peuvent être inclus n’importe où dans le document

Prologue
♦ Le prologue est la section d'informations qui apparaît avant la balise de début du
document ou de l'élément racine. Il contient des informations qui s'appliquent à
l'ensemble du document, comme l'encodage des caractères, la structure du
document et les feuilles de style.
♦ Il contient :
1- Une déclaration XML qui précède tout autre balise XML :
<?xml version="..." [encoding="…"] [standalone="yes|no"] ?>
▪ L’attribut version indique la conformité du document à une version de la
norme XML
▪ L’attribut encoding indique le jeu de caractères utilisé. Par défaut, sa valeur
est UTF-8
▪ L’attribut standalone indique la présence ou non de références externes. Si la
valeur de cette attribut est "yes", l'analyseur produit une erreur si le document
fait référence à une DTD externe ou à des entités externes. La valeur par défaut
est "no". Dans ce cas l'analyseur XML acceptera des ressources externes
éventuelles sans produire d'erreur.

Prologue
2- Une déclaration de type de document (DTD) indiquant la DTD à laquelle se
conforme le document (voir plus loin). Par exemple :
<!DOCTYPE annuaire SYSTEM "annuaire.dtd">
3- On peut aussi trouver des instructions de traitement au début du document qui

sont destinées aux applications qui traitent les documents XML. Elles sont
délimitées par les chaînes de caractères '<?' et '?>'. Elles définissent une cible
(le nom de l’application à qui elles sont destinées) et des paramètres.
Par exemple :
<?xml-stylesheet type="text/xsl" href="annuaire.xsl" ?>
▪ L’instruction ne sert pas pour le document proprement dit mais sera
interprétée par l’application à laquelle elle est destinée (ici xml-stylesheet le
processeur de feuilles de style du XML).
▪ L’attribut type indique le type de feuille de style (XSL ou CSS).
▪ L’attribut href donne l’URL (« l’emplacement ») du fichier de feuille de style.

Arbre d’éléments
♦ Tout document XML se présente sous la forme d’un arbre d’éléments. Il
contient une racine, des nœuds et des feuilles (appelés éléments).
♦ Chaque document contient un et un seul élément englobant tous les autres

éléments : c’est l’élément racine. Il s’ouvre juste après le prologue et se
ferme à la fin du document. Tous les autres éléments sont imbriqués entre
ces balises de racine. Dans l’exemple précédent, l’élément racine est
<annuaire>…</annuaire>. Dans le HTML ou le XHTML, l’élément
racine est <html>…</html>.
♦ Tout élément fils est complètement inclus dans son père.

Par exemple <parent><enfant>Mohamed</parent></enfant> est incorrect.
L’écriture correcte avec une bonne imbrication des éléments est :
<parent><enfant>Mohamed</enfant></parent>

Structure d’un élément
♦ Un élément est formé d'une balise ouvrante, d'un contenu et de la balise
fermante correspondante :
<nomElement [attribut='valeur']> contenu </nomElement>
▪ <nomElement> : est la balise ouvrante de l’élément
▪ </nomElement> : est la balise fermante. Il est obligatoire sauf pour
les éléments vides
▪ contenu : est le contenu de l’élément. Il peut être :
- vide, texte, autres éléments, imbrication de texte et d’autres
éléments
- instructions de traitement, commentaires
▪ attribut='valeur' : ensemble éventuellement vide d'attributs

Structure d’un élément
♦ Le nom d’élément est libre (contrairement au HTML). Il obéit au règles suivantes :
▪ doit commencer par une lettre ou un '_' et ne peut pas commencer par les lettres
xml (ou XML ou Xml …)
▪ peut comporter des chiffres, des lettres, '-', '. ' ou '_'
▪ ne peut pas contenir des espaces
▪ peut posséder un nom de domaine : "domaineDeNoms:nomElement"
▪ est sensible à la casse. Ainsi, la balise <Nom> est différente de la balise <nom>.
La balise ouvrante et la balise fermante doivent donc être identique. Ainsi par
exemple <Nom>…</nom> est incorrect et <nom>…</nom> est correct.
Un consensus se dégage pour n’écrire les balises qu’en minuscule, limitant ainsi
les erreurs possibles.
♦ Un élément vide est un élément ne possédant pas de contenu c'est-à-dire lorsque la

balise fermante suit immédiatement la balise ouvrante : <exemple></exemple>.
Les deux balises peuvent éventuellement se contracter en une seule balise de la
forme <exemple />. Un élément vide contient des informations dans ses attributs.

Les attributs d’un élément
♦ Les attributs permettent de représenter des informations supplémentaires relatives
à un élément. Ils sont toujours spécifiés dans la balise ouvrante de l'élément.
♦ L'ordre des attributs n'a pas d'importance.
♦ Les attributs d'un élément doivent avoir des noms distincts. Il est donc impossible
d'avoir deux occurrences du même attribut dans une même balise ouvrante.
♦ Le nom d'attribut respecte les mêmes règles que les noms d'éléments. La valeur
doit être délimitée par des apostrophes ou des guillemets et ne peut contenir les
caractères ^, % et &.
♦ Les attributs réservés de XML :
- xml:lang='langue' permet de définir la langue utilisée dans l'élément et tous les
sous éléments. La langue peut être fr ou en-US ou fr-FR, ...
- xml:space='preserve' ou xml:space='default' permet de définir l'interprétation
des espaces dans l'élément et tous les sous éléments.
- xml:id='identificateur' permet d'associer une et une seule clef à un élément.
- xml:idref='identificateur' permet de faire référence à une clef.

Les commentaires
♦ Les commentaires se déclarent de la même façon qu'en HTML. Ils
commencent donc par .
Ex : 
Le contenu du commentaire sera ignoré par les analyseurs XML
♦ Ils ne peuvent pas contenir la chaîne '--' et ne peuvent pas être imbriqués.
♦ Ils peuvent être présents dans le prologue et en particulier dans la DTD,

dans le contenu de n'importe quel élément et après l'élément racine.
♦ Ils ne peuvent jamais apparaître à l'intérieur d'une balise ouvrante ou

fermante.

Entités prédéfinies
♦ Les caractères <, >, &, ', " ne peuvent être utilisés dans le texte, car utilisés
dans le balisage XML. Afin d'avoir la possibilité d'utiliser ces caractères
qui ont un sens particulier en XML, il y a des entités de caractères qui
sont prédéfinies :
Caractère Entité
< <
> >
& &
' '
" "
Les autres entités de caractères couramment utilisées en HTML (

par exemple) ne sont pas prédéfinies en XML.

Section CDATA
♦ Une section CDATA permet de définir un bloc de caractères ne devant pas être analysé
en tant qu’XML et donc il est ignorée par les analyseurs XML. Ceci permet entre
autres de garder dans un bloc de texte un exemple de code à afficher tel quel.
♦ Syntaxe : <! [CDATA[ … ] ]>
Remarques : - La section CDATA ne doit pas contenir ]]>
- Les sections CDATA ne peuvent pas être imbriquées c.à.d qu'une section
CDATA ne peut pas contenir une autre section CDATA à l'intérieur d'elle-même.
♦ Exemple :
<program>
if(k<20 & k>0) return k; incorrect
</program>
<program>
<![CDATA[if(k<20 & k>0) return k;]]> correct
</program>
Document bien formé et valide
♦ Un document est dit "bien formé" s’il respecte la syntaxe XML :
▪ Le document doit contenir un et un seul élément racine
▪ Toutes les balises avec un contenu doivent être fermées
▪ Toutes les balises sans contenu doivent se terminer par les caractères />
▪ Les balises ne doivent pas se chevaucher
▪ Les valeurs d’attributs doivent être entre guillemets ou apostrophes
▪ La casse doit être respectée pour toutes les occurrences de noms de balise
♦ Un document XML est dit "valide" s’il possède une DTD (ou un schéma
XML) et si sa syntaxe est conforme aux règles de la DTD (ou du schéma
XML). Un document "valide" est obligatoirement "bien formé".

Définition de type de document
(DTD)
♦ Une DTD (Document Type Definition) est une grammaire qui a pour rôle
de définir précisément la structure d'un document. Il s'agit d'un certain
nombre de contraintes que doit respecter un document pour être valide.
Ces contraintes spécifient quels sont les éléments qui peuvent apparaître
dans le contenu d'un élément, l'ordre éventuel de ces éléments et la
présence de texte brut. Elles définissent aussi, pour chaque élément, les
attributs autorisés et les attributs obligatoires.
♦ La DTD peut être interne, externe ou mixte. Elle est interne si elle est
directement incluse dans le document. Elle est externe si le document
contient seulement une référence vers un autre document contenant la
DTD. Elle est finalement mixte si elle est constituée d'une partie interne
et d'une partie externe.

Déclaration de la DTD
♦ La déclaration de la DTD du document doit être placée dans le prologue et est
introduite par le mot clé DOCTYPE et a la forme générale suivante :
<!DOCTYPE elementRacine ... >
où elementRacine est le nom de l'élément racine du document auquel cette DTD
s'applique. Il est suivi du contenu de la DTD dans le cas d'une DTD interne ou
de l'URL du fichier contenant la DTD dans le cas d'une DTD externe :
▪ DTD interne : <!DOCTYPE elementRacine [ déclaration des éléments ]>
▪ DTD externe : <!DOCTYPE elementRacine SYSTEM "nomFichier">
ou <!DOCTYPE elementRacine PUBLIC "name" "URL">
Les DTD privées (SYSTEM) sont accessibles uniquement en local (sur la
machine de développement). Les DTD publiques (PUBLIC) sont disponibles
pour tout le monde, étant accessibles grâce à une URL.
▪ DTD mixte : <!DOCTYPE elementRacine SYSTEM "nomFichier" [
déclaration des éléments
]>

DTD : Exemple d’une DTD interne
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!DOCTYPE annuaire [
<!ELEMENT annuaire (personne)+>
<!ELEMENT personne (nom, prenom, telephone)>
<!ELEMENT nom (#PCDATA)>
<!ELEMENT prenom (#PCDATA)>
<!ELEMENT telephone (#PCDATA)>
<!ATTLIST telephone type (fixe | portable) #IMPLIED>
]>
<annuaire>
<personne>
<nom> Zrouri </nom>
<prenom> Mohamed </prenom>
<telephone> 0684566695 </telephone>
</personne>
…
</annuaire>
DTD : Exemple d’une DTD externe
Le document XML :
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE annuaire SYSTEM "annuaire.dtd">
<annuaire>
<personne>
<nom> Zrouri </nom>
…
</personne>
…
</annuaire>
Le fichier de DTD externe (ici dans le même répertoire) "annuaire.dtd" contient :
<!ELEMENT annuaire (personne)+>
<!ELEMENT personne (nom, prenom, telephone)>
<!ELEMENT telephone (#PCDATA)>
<!ATTLIST telephone type (fixe | portable) #IMPLIED>
DTD : Déclaration des éléments
♦ La déclaration d'un élément est de la forme :
<!ELEMENT nomEl (modèle)>
ou nomEl est le nom de l’élément et modèle est le modèle de contenu de
l’élément. Ce dernier peut être :
▪ Vide : l’élément n’a pas de contenu (mais peut avoir des attributs)
▪ Quelconque : le contenu de l’élément est un contenu quelconque
bien formé
▪ Données : l’élément contient du texte
▪ Éléments : l’élément est composé d’autres éléments (ses fils)
▪ Mixte : l’élément contient un mélange de texte et de sous-éléments

1. Élément vide :
▪ Syntaxe : <!ELEMENT nomEl EMPTY>
▪ Exemple : <!ELEMENT img EMPTY> pour la balise <img /> en html
2. Élément avec un contenu quelconque :
▪ Syntaxe : <!ELEMENT nomEl ANY>
▪ Remarques :
- Cet élément peut contenir tout autre élément défini dans la DTD. Il peut
aussi contenir du texte.
- Cet élément est « risqué » car il ne permet pas de contrôler vraiment les
éléments enfant.
3. Élément comprenant des caractères à afficher :
▪ Syntaxe : <!ELEMENT nomEl (#PCDATA)>
▪ Exemple : <!ELEMENT prenom (#PCDATA)>

4. Élément avec des éléments enfants en séquence :
▪ Syntaxe : <!ELEMENT nomEl (elementEnf1, elementEnf2, …, elementEnfn)>
▪ Exemple : <!ELEMENT enfants (fils, fille)>
▪ Remarques :
- Les éléments enfants doivent apparaître dans le même ordre dans le document XML
- Les éléments enfants doivent être déclarés : <!ELEMENT enfants (fils, fille)>
<!ELEMENT fils (#PCDATA)>
<!ELEMENT fille (#PCDATA)>
5. Élément avec des éléments enfants en alternatif :

▪ Syntaxe : <!ELEMENT nomEl (elementEnf1|elementEnf2|…|elementEnfn)>
▪ Remarques :
- L’élément peut contenir elementEnf1ou elementEnf2 ou …, ou elementEnfn
- Les éléments enfants doivent être déclarés
▪ Exemple : <!ELEMENT telephone (national | international)>

6. Répétition de contenu :
▪ Les caractères ? , + , * ajoutés à un contenu permettent de le répéter
respectivement de 0 à 1 fois (?), de 1 à n fois (+) ou de 0 à n fois (*)
▪ Exemple : <!ELEMENT personne (nom, prenom+, email?, tel*)>
7. Élément avec un contenu mixte :

▪ Syntaxe : <!ELEMENT nomEl (#PCDATA|elementEnfant1|…|elementEnfantn)*>
▪ Remarques :
- Cet élément peut contenir à la fois du texte et des éléments enfants
- Le mot clé #PCDATA doit être en début de la liste du contenu
▪ Exemple : <!ELEMENT chapitre (#PCDATA | para)*>

DTD : Déclaration des attributs
♦ La déclaration d'un attribut dans une DTD est de la forme :
<!ATTLIST nomElement nomAttribut typeAttribut mode>
▪ nomElement spécifie l'élément auquel cet attribut appartient
▪ nomAttribut est le nom de l'attribut en cours de définition
▪ typeAttribut définit le type de donnée de l'attribut. Il existe plusieurs types d’attributs,
les plus courants sont :
- CDATA : chaîne de caractères non analysée (peut contenir n'importe quel
caractère sauf <, >, &, ' ou " )
- Énumération : liste de valeurs séparées par |
<!ATTLIST nomElement nomAttribut (Valeur1 | Valeur2 | ... ) >
- NMTOKEN : un seul mot sans espace (ne peut contenir que des lettres,
des chiffres, soulignés, tirets, points et deux-points)
- NMTOKENS : liste de mots, séparés par des espaces
- ID : identifiant unique de l’élément (ne peut être constituée que de caractères
autorisés pour le type NMTOKEN et doit commencer par une lettre)
- IDREF : une référence vers un identifiant du document
- IDREFS : des références vers plusieurs identifiants du document, séparés par
des espaces
▪ mode précise le caractère obligatoire ou non de l'attribut :
- #REQUIRED : l'attribut doit être renseigné
- #IMPLIED : l'attribut est facultatif et n’a pas de valeur par défaut particulière
- #FIXED 'val' : l'attribut est facultatif mais s’il est présent il ne peut prendre que
val comme valeur
- 'valeurParDefaut' : l'attribut est facultatif mais s’il n’est pas présent sa valeur est
valeurParDefaut
♦ Remarques :
- Il ne peut y avoir deux ID pour une même liste d’attributs concernant un élément
- Les valeurs des ID doivent tous être différents au sein du document XML.
- Une valeur utilisée dans un attribut IDREF ou IDREFS doit obligatoirement
correspondre à celle d’un attribut ID.

♦ Exemple :
▪ Le fichier document.dtd :
<!ELEMENT document (personne+, livre+)>
<!ELEMENT personne (nom, prenom)>
<!ATTLIST personne id ID #REQUIRED>
<!ELEMENT livre (#PCDATA)>
<!ATTLIST livre auteur IDREF #REQUIRED>

▪ Le fichier XML :
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE document SYSTEM "document.dtd">
<document>
<personne id="id1">
<nom>Pillou</nom>
<prenom>Jean François</prenom>
</personne>
<personne id="id2">
<nom>Delannoy</nom>
<prenom>Claude</prenom>
</personne>
<livre auteur="id1">Tout sur le développement logiciel</livre>
<livre auteur="id2">Programmer en Java</livre>
</document>
♦ Attributs multiples :
▪ Un élément peut posséder plusieurs attributs
▪ Tous les attributs propres à un élément sont déclarés dans la même instruction :
<!ATTLIST nomElement
nomAttribut1 typeAttribut1 mode1
nomAttribut2 typeAttribut2 mode2
…
>
▪ Exemple :
<!ELEMENT auteur (#PCDATA) >
<!ATTLIST auteur
genre (Masculin | Féminin ) #REQUIRED
ville CDATA #IMPLIED
>
DTD : Déclaration des entités
♦ Une entité peut-être considérée comme un alias permettant de réutiliser des
informations au sein du document XML ou de la définition DTD.
♦ Une entité analysable peut contenir une chaîne de caractères, un document XML ou
un fragment de document XML bien formé.
♦ L'intérêt d'une entité consiste à pouvoir remplacer autant de fois que nécessaire dans
le document XML l'entité par le texte qui lui est associé. Il existe plusieurs types
d'entités :
▪ Les entités prédéfinies concernent les caractères réservés en XML. Il existe 5
entités prédéfinies : lt, gt, amp, apos et quot (caractères < > & ' ")
▪ Les entités paramètres sont destinées à être utilisées au sein de la DTD
▪ Les entités générales sont destinées à être utilisées dans le corps du document
♦ La définition d'une entité associe le nom de l'entité (qui doit être un nom XML) à un
texte de remplacement. Elle est définie avec la balise <!ENTITY …>, et dite :
– Interne si sa valeur est donnée dans la DTD
– Externe si sa valeur est fournie dans un fichier externe à la DTD

1. Entité générale interne :
▪ Déclaration de l’entité dans la DTD :
- Syntaxe : <!ENTITY nom_entité "valeur">
- Exemple : <!ENTITY esto "École Supérieure de Technologie d’Oujda">
▪ Appel de l’entité dans le document XML :
- Syntaxe : &nom_entité;
Le parseur XML remplace l’appel d’entité par la chaîne de caractères
correspondante.
- Exemple : &esto;

2. Entité générale externe (analysable) :
Syntaxe : <!ENTITY nom_entité SYSTEM "nomFichier">
Le texte de remplacement est défini dans un fichier externe.
▪ Appel de l’entité dans le document XML :
Syntaxe : &nom_entité;
Le parseur XML remplace l’appel d’entité par le contenu du fichier correspondant.
▪ Exemple :
<?xml version="1.0"?>
<!DOCTYPE livre SYSTEM "livre.dtd" [
<!ENTITY chap1 SYSTEM "chapitre1.xml">
<!ENTITY chap2 SYSTEM "chapitre2.xml">
]>
<livre> &chap1; &chap2; </livre>

3. Entité paramètre interne :
Syntaxe : <!ENTITY % nom_entité "valeur">
▪ Appel de l’entité dans la DTD :
Syntaxe : %nom_entité;
▪ Exemple :
<!ENTITY % statut "statut (public|privé) #IMPLIED">
<!ELEMENT article (#PCDATA)>
<!ATTLIST article date CDATA #IMPLIED
%statut;
>
▪ Remarque: Une entité paramètre est utilisée dans la DTD même où elle
est définie. Elle doit obligatoirement être définie avant d'être utilisée.
4. Entité paramètre externe :
Syntaxe : <!ENTITY % nom_entité SYSTEM "url_entité">
▪ Appel de l’entité dans la DTD :
Syntaxe : %nom_entité;
▪ Exemple :
<!ENTITY % chapitre SYSTEM "chapitre.dtd">
<!ENTITY % tableau SYSTEM "tableau.dtd">
%chapitre;
%tableau;

DTD : Commentaires
♦ Une DTD peut contenir des commentaires qui utilisent la syntaxe des
commentaires XML délimités par les chaînes de caractères .
♦ Les commentaires sont placés au même niveau que les déclarations
d'éléments, d'attributs et d'entités.
♦ Ils ne peuvent pas apparaître à l'intérieur d'une déclaration.
♦ Exemple :

<!ELEMENT biblio (livre)+ >

<!ELEMENT livre (titre, auteur*, nbresPages) >
...

Espaces de noms
♦ XML définit un système permettant de créer des balises modulaires, c'est-à-dire
pouvoir donner la possibilité d'utiliser des balises provenant de différents
langages à balise au sein d'un même document grâce à la notion d'espace de
noms (namespace).
♦ La définition d'un espace de nom permet d'associer toutes les balises d'un langage à
un groupe afin d'être capable de mêler différents langages à balise dans un
même document XML (par exemple, pouvoir mettre du XHTML, XSLT dans
un même document).
♦ L'utilité des espaces de noms est de pouvoir avancer sur les notions de documents
composites, quelle que soit la nature des contenus des documents.
Par exemple, supposons un document qui contienne ses propres paragraphes
(nommés P) et qui doive par ailleurs comporter des fragments de contenus
HTML. HTML définissant ses propres paragraphes (aussi nommés P), il peut y
avoir contradiction entre les deux définitions. La notion d'espace de noms lève
cette contradiction et permet aux deux éléments de coopérer. L'un, par exemple
celui issu du modèle HTML, sera préfixé par son espace de noms : html:P.

Espaces de noms
♦ Les espaces de noms donnent aux éléments et aux attributs des noms uniques, sur
Internet.
♦ Un espace de noms est identifié par un URI (Uniform Ressource Identifier). Cet
URI est très souvent une URL mais il est sans importance que l'URL pointe
réellement sur un document. Cet URI garantit seulement que l'espace de noms
soit identifié de manière unique. Dans la pratique, l'URL permet aussi souvent
d'accéder à un document qui décrit l'espace de noms.
♦ Voici quelques espaces de noms classiques :

XML http://www.w3.org/XML/1998/namespace
XHTML http://www.w3.org/1999/xhtml
Schémas XML http://www.w3.org/2001/XMLSchema
Instances de schémas http://www.w3.org/2001/XMLSchema-instance
XSLT http://www.w3.org/1999/XSL/Transform

Espaces de noms
♦ Déclaration d’un espace de noms (avec préfixe) :
▪ Syntaxe :
<prefixe:nomElement xmlns:prefixe="URI de l’espace de noms"> …</ prefixe:nomElement>
▪ Exemple :
<htm:html xmlns:htm="http://www.w3.org/1999/xhtml">
<htm:head>
<htm:title>Espace de noms</htm:title>
</htm:head>
<htm:body>
<htm:a href="http://www.w3.org/1999/xhtml">Pour plus de détails </htm:a>
</htm:body>
</htm:html>
▪ Remarques :
- Le choix du préfixe est sans importance. (Les préfixes xml et xmlns sont réservés).
- Il est inutile de préfixer les attributs pour qu'ils soient dans le même espace de nommage de
l'élément dont ils dépendent.
- Il est possible d'associer à un élément des attributs qui font partie d'un autre espace de
nommage. Dans ce cas, l’attribut doit avoir un préfixe.
Espaces de noms
♦ Déclaration d’un espace de noms par défaut :
▪ Syntaxe : <nomElement xmlns="URI de l’espace de noms"> …</ nomElement>
▪ Exemple :
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Espace de noms</title>
</head>
<body>
<a href="http://www.w3.org/1999/xhtml">Pour plus de détails </a>
</body>
</html>

Espaces de noms
♦ Visibilité d’une déclaration d’un espace de noms :
▪ La déclaration d’un espace de noms muni d’un préfixe est visible dans l’élément la
contenant et dans tous ses descendants sauf ceux pour lesquels un nouvel espace de
même préfixe est déclaré.
Exemple : <sc:A xmlns:sc="http://www.maSociete1.com/">
<sc:B>
<sc:C xmlns:sc="http://www. maSociete2.com/">
<sc:D>abcd</sc:D>
</sc:C>
</sc:B>
</sc:A>
▪ La déclaration d’un espace de noms par défaut est visible dans l’élément la contenant et
dans tous ses descendants sauf ceux pour lesquels cette déclaration est annulée ou ceux
pour lesquels un nouvel espace de noms est déclaré.
Exemple : <A xmlns="http://www.maSociete.com/">
<B> <C xmlns=""> <D>abcd</D> </C> </B>
</A> 

Espaces de noms
♦ Utilisation de plusieurs espaces de noms :
▪ Dans un document, on peut utiliser simultanément plusieurs espaces de noms.
▪ Exemple :
<commande xmlns:produit="http://localhost/XML/produit"
xmlns:client="http://localhost/XML/client">
<produit:numero>p49393</produit:numero>
<produit:nom>PC</produit:nom>
<produit:quantite>1</produit:quantite>
<produit:prix>5000DH</produit:prix>
<client:numero>c2029</client:numero>
<client:nom>Mohamed Azais</client:nom>
<client:adresselivraison>15 rue 3 hay elqods, oujda</client:adresselivraison>
</commande>
▪ Remarque :
Lorsqu’on utilise plusieurs espaces de noms dans un document XML, on peut définir un
espace de noms comme l'espace de noms par défaut afin de créer un document plus
clair.

Espaces de noms
♦ Noms non qualifiés :
▪ Syntaxe : nom
▪ Un nom non qualifié est un nom d'élément ou d'attribut XML qui n'est pas
associé à un espace de noms. Cela parce qu'il n'a aucun préfixe d'espace de
noms et qu'aucun espace de noms par défaut n'a été déclaré. (Remarque : Tous
les noms d'attribut sans préfixe sont non qualifiés car ils ne sont jamais
automatiquement associés à un espace de noms par défaut)
♦ Noms qualifiés :
▪ Syntaxe : [préfixe:]nom
▪ Un nom qualifié est un nom d'élément ou d'attribut associé à un espace de noms.
Il existe trois types possibles de noms qualifiés :
- les noms d'élément sans préfixe contenus dans la portée d'une
déclaration d'espace de noms par défaut ;
- les noms d'élément préfixés ;
- les noms d'attribut préfixés.
Techniques d'affichage d'un fichier
XML dans un navigateur
♦ Les balises XML ne sont pas interprétables par les navigateurs (balises non
prédéfinies). Si on affiche le contenu d’un fichier XML à partir d'un navigateur
on obtiendra le contenu du fichier lui même avec les balises.
Exemple :
♦ Pour afficher les données d’un fichier XML dans un navigateur Web, il existe deux
possibilités :
▪ Faire appel à une feuille de style CSS classique
▪ Faire appel à une feuille de style extensible XSL
Afficher le XML avec CSS
♦ Pour afficher les balises XML, on peut faire appel aux feuilles de style CSS. Pour chaque
balise dans le fichier XML, un élément de style va être intégré pour l’affichage par le
navigateur.
♦ Pour que le fichier XML puisse faire appel à la feuille de style CSS, il suffit de rajouter la
ligne suivante dans le prologue du fichier XML :
<?xml-stylesheet href="nomDuFichier.css" ?>
♦ Exemple : Nous allons afficher le fichier annuaire.xml en faisant appel à la feuille de style
annuaire.css ci-dessous :
annuaire {}
personne { display: block;
margin-top: 6px; }
nom, prenom, telephone { display: inline;
font-family: Arial;
font-size: 13pt; }
nom { padding-left: 12pt;
font-weight: bold; }
telephone { background-color: lightblue; }
Afficher le XML avec CSS
Le fichier annuaire.xml : L’affichage de annuaire.xml
dans un navigateur donne :
<?xml-stylesheet href="annuaire.css" ?>
<annuaire>
<personne>
<nom> Zrouri </nom>
<prenom> Mohamed </prenom>
</personne>
<personne>
<nom> Boularcha </nom>
<prenom> Malika </prenom>
</personne>
…
</annuaire>

Afficher le XML avec CSS :
limitations
♦ Avec CSS, impossible de :
▪ déplacer ou réorganiser des éléments
Ex : mettre dans annuaire.xml le nom après le prénom
▪ changer le nom des balises
Ex : convertir l’élément URL en un véritable hyperlien
▪ sélectionner un contenu spécifique. Il est fréquent de ne souhaiter
publier qu'une partie d'un document, de la même façon qu'il n'est
généralement pas souhaitable d'afficher le contenu entier d'une base
de données
▪ trier le contenu d'un document

Afficher le XML avec XSL
♦ Le XSL pour eXtensible Stylesheet Language (langage extensible de feuilles de
style) est un langage de spécification de styles spécifiquement conçu pour XML.
Un fichier de feuilles de style XSL reprend des données XML et produit la
représentation ou l’affichage de ce contenu XML selon les souhaits du concepteur
de la page web.
♦ Pour afficher une donnée XML dans un navigateur, il faut franchir trois étapes :
1- Aller chercher cette donnée.
2- Transformer cette donnée XML vers le format d’un langage de présentation.
3- Construire le langage de présentation en incluant cette donnée.
L’étape 1 est effectuée par XPath (langage d’adressage), l’étape 2 par XSLT
(langage de transformation) et l’étape 3 par XHTML (ou HTML).
♦ Remarque : Les langages XSLT (XSL Transform) et XPath sont contenus dans le
langage XSL. Nous identifions par la suite ces deux langages (XSLT et XPath)
sous le vocable générale XSL.

Afficher le XML avec XSL
♦ Le XSL ne permet pas uniquement l'affichage de XML. Il permet aussi :
- de sélectionner une partie des éléments XML
- de trier des éléments XML
- de filtrer des éléments XML en fonction de certains critères
- de choisir des éléments
- de retenir des éléments par des tests conditionnels
♦ Le principe de fonctionnement de XSL est le suivant :

▪ Le XSL est dérivé du XML. Le document XSL reprend donc la structure et la
syntaxe de n'importe quel document XML.
▪ Le document XSL comporte un document HTML ou XHTML qui sera quant à lui
reconnu par le navigateur et qui servira de support à tout ou partie des données du
document XML associé.
▪ Le XSL fonctionne avec une ou plusieurs "templates", sorte de gabarit pour
définir comment afficher des éléments du fichier XML. Les éléments concernés
du fichier XML sont déterminés par l'attribut "match".
Structure et utilisation d’un fichier XSL
♦ Un fichier XSL est un document XML de la forme :
<?xml version="1.0" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" /> 
…
<xsl:template match="…">
…
</xsl:template>
…
</xsl:stylesheet>
Remarques :
- L’attribut xmlns:xsl fait référence à l’espace de noms utilisé.
- L'élément <xsl:template …> définit une règle XSL. Un document XSL se compose
d’une ou de plusieurs règles (template) qui permettent de construire le document en
sortie.
♦ L’association du fichier XSL au fichier XML se fait à l’aide de l'instruction suivante :
<?xml-stylesheet type="text/xsl" href="nomFichier.xsl" ?>
XSL : Premier exemple
- Soit le fichier annuaire.xsl :
<xsl:output method="html" />
<xsl:template match="/">
<html>
<head><title>Test de XSL</title></head>
<body>
<p>
Nom : <b> <xsl:value-of select="annuaire/personne/nom" /> </b><br />
Prénom : <b> <xsl:value-of select="annuaire/personne/prenom" /> </b><br />
Téléphone : <b> <xsl:value-of select="annuaire/personne/telephone" /> </b>
</p>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XSL : Premier exemple
- Soit le fichier annuaire.xml :
<annuaire>
<personne>
<nom>Zrouri</nom>
<prenom>Hafida</prenom>
<telephone>0684566695</telephone>
</personne>
</annuaire>
- L’affichage de annuaire.xml par un navigateur donne le résultat suivant :

XSL : Structure d’une règle
♦ Syntaxe :
<xsl:template match="chemin">
… transformations …
</xsl:template>
- chemin spécifie les nœuds sur lesquels la règle doit s'appliquer.
- transformations définit la forme du résultat à générer sur le flot de sortie quand
la règle sera activée.
♦ Exemple :
<xsl:template match="/"> … </xsl:template>
- Cette balise template va déterminer un gabarit dans lequel on va transformer des
éléments du fichier XML sous une forme que le navigateur pourra afficher.
- Les éléments du fichier XML sont déterminés par l'attribut match="/". Le slash /
entre guillemets signale que sont concernées toutes les balises XML du
document associé à partir de la racine.

XSL : Extraction de données
♦ Syntaxe :
<xsl:value-of select="chemin d'accès/élément" />
- Dans l'attribut select, on détermine le chemin d'accès vers la balise XML souhaitée
(puisque le XML est structuré) comme le chemin d'accès de répertoire en sous répertoire
vers un dossier.
- Cette balise permet d’afficher dans le document résultat, le contenu de l’élément
sélectionné par l’attribut select.
♦ Exemple :
<xsl:template match="nom">
<h1> <xsl:value-of select="." /> </h1>
</xsl:template>
♦ Remarques:
- L'élément <xsl:value-of> ne peut traiter qu'un seul nœud à la fois.
- L'élément <xsl:value-of> peut non-seulement sélectionner des éléments XML, mais aussi
des attributs par l'intermédiaire du signe @ ainsi que des paramètres ou des variables avec
$ (voir les exemples plus loin).

XSL : Sélection des noeuds
♦ Expression Signification
/ Racine du document
//balise Tous les nœuds qui correspondent à la balise
. Nœud courant
.. Nœud parent
@ Sélection d’attribut
* N’importe quel nœud
♦ Exemple :
/personne/prenom : tous les nœuds prenom des personnes
//prenom : tous les nœuds prenom
//livre/@* : tous les attributs de tous les nœuds livre
//img/@id : tous les attributs id de tous les nœuds img
//paragraphe[@langue='fr'] : tous les nœuds paragraphe qui contiennent un
attribut langue dont la valeur est fr

XSL : Appeler d’autres règles
♦ La balise <xsl:apply-templates> permet de déclencher l’application de règles sur
un ensemble de nœuds.
♦ Syntaxe :
<xsl:template match="…" >
…
<xsl:apply-templates [select="chemin"] />
…
</xsl:template>
- Applique l’ensemble des règles aux nœuds atteints par chemin

- chemin désigne les nœuds auxquels la règle doit s’appliquer
- Un simple apply-templates sans l’attribut select examine tous les nœuds enfants
(de l'élément en cours) dans l’ordre. Si une règle qui correspond à un nœud est
détectée, elle sera appliquée.

♦ Exemple :
- Soit le fichier annuaire.xml :
<annuaire>
<personne>
<nom>Zrouri</nom>
<prenom>Hafida</prenom>
</personne>
</annuaire>
Pour comprendre le rôle de l’instruction xsl:apply-templates, nous allons
afficher ce fichier xml avec une feuille de style xsl sans et avec utilisation de la
balise <xsl:apply-templates>.

♦ Exemple :
- Soit le fichier annuaire.xsl sans l’instruction xsl:apply-templates :
<html>
<head><title> Exemple de apply-templates </title></head>
<body>
<h1>Annuaire</h1>
</body>
</html>
</xsl:template>
<xsl:template match="annuaire/personne">
<p style="font-size: 2em"> Nom : <xsl:value-of select="nom" /> <br />
Prénom : <xsl:value-of select="prenom" /> <br />
Téléphone : <xsl:value-of select="telephone" />
</p>
</xsl:template>
</xsl:stylesheet>

L’affichage du fichier xml avec la feuille de style précédente donne :
Le processeur commence la transformation en cherchant une template pour la racine

du document, en trouve un correspondant dans la feuille de style et l'applique. Il
génère en sortie le texte "Annuaire", comme spécifié dans la template. L'arbre a été
traité et la transformation s'arrête sans considérer les descendants de la racine. La
deuxième template n'est jamais utilisé.

♦ Exemple :
- Soit le fichier annuaire.xsl avec l’instruction xsl:apply-templates :
<html>
<head><title> Exemple de apply-templates </title></head>
<body>
<h1>Annuaire</h1>
<xsl:apply-templates />
</body>
</html>
</xsl:template>
<xsl:template match="annuaire/personne">
<p style="font-size:2em"> Nom : <xsl:value-of select="nom" /> <br />
Prénom : <xsl:value-of select="prenom" /> <br />
Téléphone : <xsl:value-of select="telephone" />
</p>
</xsl:template>
</xsl:stylesheet>
En ajoutant l’instruction xsl:apply-templates dans le fichier xsl, on obtient l’affichage
suivant :
La transformation commence de la même manière : la règle correspondant à la racine

est appliqué, le texte "Annuaire" est reproduit en sortie. L'instruction apply-templates
intime au processeur de poursuivre la transformation pour les enfants de l'élément
courant. Lorsque le processeur rencontre l’élément personne, la règle correspondante
est appliquée.

XSL : Les boucles
♦ Syntaxe :
<xsl:for-each select="chemin"> … </xsl:for-each>
♦ Exemple :
Supposons que notre fichier annuaire.xml contient plusieurs personnes et que
nous voulons les afficher dans un tableau sous la forme suivante :
Chaque ligne comporte les données d’une personne. Pour afficher toutes les
lignes du tableau nous utilisons une boucle avec la balise <xsl:for-each> (voir
le script annuaire.xsl).

XSL : Les boucles
♦ Le fichier annuaire.xml :
<annuaire>
<personne>
<nom> Zrouri </nom>
<prenom> Hafida </prenom>
</personne>
<personne>
<nom> Boularcha </nom>
<prenom> Malika </prenom>
</personne>
<personne>
<nom> Azais </nom>
<prenom> Regis </prenom>
</personne>
</annuaire>
XSL : Les boucles
♦ Le fichier annuaire.xsl :
<html>
<head><title>Exemple de for-each</title></head>
<body>
<table border="1">
<caption>Listes des personnes</caption>
<tr><th>Nom</th><th>Prénom</th><th>Téléphone</th></tr>
<xsl:for-each select="annuaire/personne">
<tr>
<td><xsl:value-of select="nom" /></td>
<td><xsl:value-of select="prenom" /></td>
<td><xsl:value-of select="telephone" /></td>
</tr>
</xsl:for-each>
</table></body></html>
</xsl:template>
</xsl:stylesheet>

XSL : Trier les données
♦ Le langage XSL permet de trier les données affichées selon un critère.
♦ Syntaxe :
<xsl:sort select="nomElément | @attribut" order="ascending|descending"/>
- nomElément désigne la balise XML servant de critère de tri
- par défaut la valeur de order est ascending (tri dans l’ordre croissant)
- on ajoute les éléments <xsl:sort> comme fils d’un élément <xsl:for-each> ou d’un
élément < xsl:apply-templates >. Le 1er fils <xsl:sort> spécifie la clé primaire du tri,
le 2ème fils <xsl:sort> spécifie la clé de tri secondaire et ainsi de suite.
Remarque : Par défaut les nœuds sont triés sur leur position.
♦ Exemple :
Si on souhaite trier les résultats de notre exemple précèdent en ordre croissant (selon
le nom), Il suffit de rajouter la ligne suivante dans le code du fichier annuaire.xsl :
<xsl:sort select="nom" order="ascending"/>
juste après la ligne : <xsl:for-each select="annuaire/personne" >
Nous obtenons l’affichage suivant :

XSL : Filtrer les données
♦ Le langage XSL permet aussi de filtrer les données du fichier XML associé selon
des critères tels que égal, différent de, plus grand que, plus petit que. Il suffit
d’utiliser l’attribut select="chemin_d’accès[…]"
Les opérateurs possibles sont :
- = pour égal
- != pour différent
- > pour plus grand que
- < pour plus petit que
- >= pour plus grand ou égal
- <= pour plus petit ou égal
Exemple :
- personne[nom] identifie tout élément <personne> possédant un élément <nom>
- personne[@id] identifie tout élément <personne> possédant un attribut id
- personne[nom='Boularcha'] identifie tout élément <personne> possédant un
élément enfant <nom> dont le texte est Boularcha
- nom[.='Boularcha'] identifie tout élément <nom> dont la valeur est Boularcha
♦ Le fichier annuaire.xml :
♦ Exemple : <?xml version="1.0"?>
Dans le fichier annuaire.xml ci- <annuaire>
contre, on souhaite afficher que les <personne>
personnes ayons le nom Boularcha. <nom>Boularcha</nom>
<prenom>Morad</prenom>
</personne>
<personne>
<nom>Boularcha</nom>
<prenom>Malika</prenom>
</personne>
<personne>
<nom>Azais</nom>
<prenom>Regis</prenom>
</personne>
</annuaire>

<html>
<head><title> Exemple de Filtre </title></head>
<body>
<table border="1">
<xsl:for-each select="annuaire/personne[nom='Boularcha']">
<tr>
<td><xsl:value-of select="nom" /></td> ♦ On obtient l’affichage :
</tr>
</xsl:for-each>
</table>
</body></html>
</xsl:template>
</xsl:stylesheet>
XSL : Choisir des données
♦ L'élément xsl:if permet d'effectuer un test conditionnel simple basé sur l'expression
définie dans l'attribut test. Si cette condition est vérifiée alors le processeur traite les
données contenues dans l'élément, sinon celles-ci sont ignorées.
La condition est une expression booléenne constituée d’un ou plusieurs tests,
composés avec les connecteurs logiques and et or.
♦ Syntaxe : <xsl:if test="condition"> …traitement… </xsl:if>
Remarques :
- Pas d’instruction else !
- Pour tester si un élément existe et/ou possède un contenu :
<xsl:if test="elt"> est vrai si le nœud courant a un enfant appelé <elt>, vide ou non.
<xsl:if test="not(elt)"> est vrai si le nœud courant n’a pas d’enfant appelé <elt>.
<xsl:if test="elt !=''"> est vrai si le nœud courant a un enfant non-vide appelé <elt>.
<xsl:if test="elt =''"> est vrai si le nœud courant a un enfant vide appelé <elt />.
♦ Exemple :
Dans le fichier annuaire.xml précédent, on souhaite afficher que les personnes ayons
le prénom Malika. Pour se faire, nous utilisons l’élément xsl:if avec la condition
test="prenom='Malika'".
<html>
<head><title> Exemple de xsl:if </title></head>
<body>
♦ On obtient l’affichage :
<table border="1">
<xsl:if test="prenom='Malika'">
<tr> <td><xsl:value-of select="nom" /></td>
</tr>
</xsl:if>
</xsl:for-each>
</table> </body></html>
</xsl:template>
</xsl:stylesheet>

♦ Voici une autre illustration de cette possibilité de choix : ne retenir dans notre
exemple d’annuaire que les personnes ayons un numéro de téléphone supérieur
à 0633333333.
Il suffit de modifier la balise <xsl:if> du fichier annuaire.xsl précèdent. La
condition s’exprime par test="telephone > 0633333333"
(> pour le signe >).

XSL : Choix conditionnels
♦ Le XSL permet de faire un choix conditionnel par la balise <xml:choose>. A l'intérieur
de cette balise, on peut déterminer une action lorsque une condition est vérifiée
(<xsl:when>) et dans le cas contraire prévoir une autre action (<xsl:otherwise>).
♦ Syntaxe : ♦ Exemple :
<xsl:choose>
<xsl:when test="condition1"> Nous allons reprendre
notre fichier
…traitement… annuaire.xml précédent
</xsl:when> et nous affichons les
[<xsl:when test="condition2"> personnes ayant le nom
…traitement… Boularcha avec un
arrière plan de couleur
</xsl:when> jaune, les autres seront
…] affichés normalement.
[<xsl:otherwise>
…traitement…
</xsl:otherwise>]
</xsl:choose>

XSL : Choix conditionnels
<html> <head><title> Exemple de xsl:choose </title></head>
<body> <table border="1"> <tr><th>Nom</th><th>Prénom</th></tr>
<xsl:choose>
<xsl:when test="nom='Boularcha'"> ♦ On obtient l’affichage :
<tr style="background-color: yellow">
<td><xsl:value-of select="nom" /></td>
<td><xsl:value-of select="prenom" /></td> </tr>
</xsl:when>
<xsl:otherwise>
<tr> <td><xsl:value-of select="nom" /></td>
<td><xsl:value-of select="prenom" /></td></tr>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each> </table> </body></html></xsl:template></xsl:stylesheet>
XSL : Importation de fichier XSLT
♦ On peut incorporer des règles d’un document XSLT dans un autre.
♦ Syntaxe : <xsl:import href ="…" />
<xsl:include href ="…" />
♦ Remarques :
▪ La différence entre <xsl:import> et <xsl:include> réside dans la gestion des conflits en
terme d’application des règles :
- avec <xsl:import> les règles importées ont une priorité moindre que celles de la feuille
qui effectue l'importation.
- avec <xsl:include> les règles du fichier inclus et courant ont la même priorité.
▪ <xsl:import> doit être placé en tête, avant tout autre descendant de <xsl:stylesheet>.
<xsl:include> peut apparaître dans n'importe quel ordre comme enfant de
<xsl:stylesheet>.
<xsl:import href ="nomFichier.xsl" />
…
</xsl:stylesheet>
XSL : Importation de fichier XSLT
♦ Exemple : Soit la feuille de styles personne.xsl que l’on souhaite importer :
<xsl:template match="personne">
<b><xsl:value-of select="nom" /></b><xsl:value-of select="prenom" /> :
<xsl:value-of select="telephone" /><br />
</xsl:template>
</xsl:stylesheet>
L’importation est alors réalisée dans le document suivant :
<xsl:import href ="personne.xsl" />
<html>
<head><title> Exemple d'importation </title><style>*{margin: 4px}</style></head>
<body><xsl:apply-templates /></body>
</html></xsl:template></xsl:stylesheet>
L’application de cette feuille de styles sur le fichier annuaire.xml précédent donne l’affichage ci-
dessus.
XSL : Templates nommés
♦ XSL permet de nommer une template et de l’appeler explicitement à n’importe quel endroit.
♦ Nommer la template : <xsl:template name="nomTemplate"> … </xsl:template>
♦ Appeler la template nommée : <xsl:call-template name="nomTemplate" />
♦ Exemple :
<html> <head><title> Exemple </title></head>
<body>
<h1>Test de template nommé</h1>
<xsl:call-template name="exemple" />
</body>
</html>
</xsl:template>
<xsl:template name="exemple">
<p style="font-size:2em"> Je suis un exemple </p>
</xsl:template>
</xsl:stylesheet>
XSL : Variables
♦ Syntaxe de la déclaration :
<xsl:variable name="nomVariable" select="valeurVariable" />
Ou <xsl:variable name="nomVariable"> valeurVariable </xsl:variable>
Remarques :
- La valeur de la variable peut être un nœud, un ensemble de nœuds, une valeur
numérique ou alphanumérique.
Ex. : <xsl:variable name="var1" select="annuaire/personne" />
<xsl:variable name="var2"><xsl:value-of select=" ."/></xsl:variable>
- La portée d’une variable est limitée à l’élément dans lequel elle a été définie.
- Une fois déclarée, la valeur d’une variable ne peut être modifiée par la suite.
♦ Syntaxe de l’invocation : $nomVariable

Ex. : <xsl:value-of select="$var1[1]"/>
<xsl:value-of select="$var2/>

XSL : Variables
♦ Exemple :
<xsl:variable name="v1">25</xsl:variable>
<xsl:variable name="v2">8.9</xsl:variable>
<html>
<head>
<title>Test de XSL</title>
</head>
<body>
<p>La somme : <xsl:value-of select="$v1+$v2" /></p>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

XSL : Paramètres
♦ Syntaxe de la déclaration :
<xsl:param name="nomParametre" select="valeurParametre" />
Ou <xsl:param name="nomParametre"> valeurParametre</xsl:param>
♦ Syntaxe de l’invocation : $nomParametre
♦ La principale différence entre une variable et un paramètre est qu’un paramètre (ou
plusieurs paramètres) peut être passé comme argument à un xsl:call-template ou
xsl:apply-templates. Cela se fait de la manière suivante :
<xsl:with-param name="nomParametre" select="valeurParametre" />
Ou <xsl:with-param name="nomParametre"> valeurParametre</xsl:with-param>

XSL : Paramètres
♦ Exemple : Remarque : L’utilisation du {} évalue l’expression et insère son résultat dans la chaîne.
<xsl:param name="couleur">green</xsl:param>
<html> <head><title> Exemple </title></head>
<body>
<h2 style="text-decoration:underline; color:{$couleur}">Annuaire</h2>
<xsl:apply-templates select="annuaire/personne[2]">

<xsl:with-param name="taille" select="'1.6em'"/>
</xsl:apply-templates>
</body>
</html>
</xsl:template>

<xsl:param name="taille" select="'10px'" />
<p style="font-size:{$taille};color:{$couleur}"><xsl:value-of select="."/></p>
</xsl:template></xsl:stylesheet>
XSL : Création d’éléments
♦ Un élément (non-XSLT) qui apparaît dans une règle modèle (template) crée un
élément de même nom et avec les mêmes attributs (sauf attributs XSLT) dans
l'arbre résultat. On peut aussi créer des éléments dont le nom est engendré à
l'exécution, avec l'instruction xsl:element.
♦ Syntaxe :
<xsl:element name="nomElément" [namespace="URI de l’espace de noms"]>
…
</xsl:element>
♦ Exemple 1:
<xsl:element name="p">
<xsl:value-of select="nom" />
</xsl:element>
→ permet de créer dans le fichier de sortie HTML un élément de paragraphe
renfermant le contenu de l'élément nom du document XML.
Nous obtenons le même résultat avec : <p><xsl:value-of select="nom" /></p>

XSL : Création d’éléments
♦ Exemple 2 :
Supposons que nous avons dans un fichier XML l’élément :
<telephone type="fixe">0584566695</telephone>
Nous pouvons créer dans l’arbre résultat, un nouveau élément fixe :
<fixe>0584566695</fixe> de la manière suivante :
<xsl:template match="telephone">
<xsl:element name="{@type}">
<xsl:value-of select="." />
</xsl:element>
</xsl:template>

XSL : Création d’attributs
♦ L’élément xsl:attribute peut être utilisé pour ajouter des attributs aux éléments résultats.
♦ Syntaxe :
<xsl:attribute name="nomAttributt" [namespace="URI de l’espace de noms"]>
…
</xsl:attribute>
Remarques :
- Ajouter un attribut à un élément remplace l’attribut existant de cet élément avec le
même nom.
- L’élément xsl:attribute doit être placée immédiatement après la balise de l’élément (si
ce dernier est créé de manière statique) ou après xsl:element qui crée l'élément dans
lequel on veut placer l'attribut (dans ce cas l’élément est créé de manière dynamique).
♦ Exemple 1:
<nom>
<xsl:attribute name="id">id1</xsl:attribute>
Zrouri
</nom>

XSL : Création d’attributs
♦ Exemple 2 :
Supposons par exemple que nous avons dans un fichier XML l'élément :
<image source="einstein.jpg" texteAlternatif="Image d’einstein" />
et que nous souhaitons obtenir dans le fichier de sortie l'élément :
<img src="einstein.jpg" alt="Image d’einstein" />
→ On peut le faire de deux manières :
1- <xsl:element name="img">
<xsl:attribute name="src">
<xsl:value-of select="@source" />
</xsl:attribute>
<xsl:attribute name="alt">
<xsl:value-of select="@texteAlternatif" />
</xsl:attribute>
</xsl:element>
2- <img src="{@source}" alt="{@texteAlternatif}" />
XSL : Création du texte
♦ L’élément <xsl:text> crée et insère un nœud de type texte dans l’arbre résultat.
♦ Syntaxe : <xsl:text> … </xsl:text>
Remarque : Par défaut, <xsl:text> préserve les espaces en sortie.
♦ Exemple :
<xsl:template match="personne[1]">
<xsl:value-of select="nom" /><xsl:text> </xsl:text><xsl:value-of select="prenom" /><br />
<a>
<xsl:attribute name="href">
<xsl:text>http://localhost/test.php?param=</xsl:text><xsl:value-of select="nom" />
</xsl:attribute>
Exemple XSL
</a>
</xsl:template>
→ Notez l’espace dans le premier élément <xsl:text>. Sans cette syntaxe, l’espace serait ignoré et
absent de la sortie.
→ Nous obtenons le même résultat pour le lien avec :
<a href="http://localhost/test.php?param={nom}">Exemple XSL</a>
XSL : Copie d’un nœud
♦ XSL permet de copier un nœud de l'arbre source vers l'arbre résultat.
♦ Syntaxe :
<xsl:copy-of select="Noeud à recopier" />
→ Copie le nœud sélectionné, ses attributs et tous ses descendants du
document source vers le document résultat.
♦ Exemple :
<xsl:copy-of select="personne"/>

XSL : Quelques fonctions utiles
♦ Fonctions de nœud :
▪ name() : retourne le nom du nœud courant.
<xsl:value-of select= "name()" />
▪ text() : retourne le contenu PCDATA d'un nœud.
<xsl:value-of select="text()" />
Exemple :
<parent>Ceci est du texte<enfant>Et cela aussi</enfant></parent>
<xsl:template match="parent"> <xsl:template match="parent">

<xsl:value-of select="." /> <xsl:value-of select="text()" />
</xsl:template> </xsl:template>
Ceci est du texte Et cela aussi Ceci est du texte

♦ Fonctions de position :
▪ position() : permet d'obtenir la position du nœud dans un ensemble de nœuds, selon l'ordre du
document.
Exemple :
- personne[position()=2] sélectionne le 2ème élément personne.
Il existe une écriture abrégée : personne[2].
- personne[position()>2] sélectionne tous les éléments personne dont le numéro d'ordre est
strictement supérieur à 2.
- personne[position() mod 2 =1] sélectionne tout élément personne qui est un descendant
impair.
▪ last() : retourne la position (le numéro) du dernier nœud d'un ensemble de nœud.
Exemple : <xsl:value-of select ="annuaire/personne[position()=last()]" /> insère la valeur
du dernier élément personne dans l’arbre résultat.
▪ current() : permet de renvoyer le nœud courant.
Exemple : <xsl:value-of select="current()" /> insère la valeur du nœud courant dans l’arbre
résultat.
▪ count(…) : retourne le nombre de nœuds d'un ensemble de nœuds.
Exemple : <xsl:value-of select ="count(annuaire/personne)" /> insère le nombre de nœuds
personne dans l’arbre résultat.
♦ Fonctions numériques :
▪ number(…) : convertit le paramètre en valeur numérique.
Nous pouvons effectuer sur les nombres, les calculs usuels à l’aide des opérateurs : +, -,
*, div, mod
▪ round(…) : arrondit le nombre qu'elle reçoit en argument à l'entier le plus proche.
▪ floor(…) : renvoie le plus grand entier inférieur ou égal à l’argument.
▪ ceiling(…) : renvoie le plus petit entier supérieur ou égal à l’argument.
Exemple : Dans une règle d’un fichier XSL :
number('1234') : <xsl:value-of select="number('1234')"/><br />
number('33texte') : <xsl:value-of select="number('33texte')"/><br />
number('-10.4') div number('2') : <xsl:value-of select="number('-10.4') div number('2')"/><br />
round(4.6) : <xsl:value-of select='round(4.6)'/><br />
round (-4.2) : <xsl:value-of select='round (-4.2)'/><br />
floor(4.2) : <xsl:value-of select="floor(4.2)"/><br />
floor(-4.2) : <xsl:value-of select="floor(-4.2)"/><br />
ceiling(4.2) : <xsl:value-of select="ceiling(4.2)"/><br />
ceiling(-4.2) : <xsl:value-of select="ceiling(-4.2)"/>

♦ Suite … :
▪ sum(…) : additionne les valeurs numériques d'un ensemble de nœuds. Elle retourne la
somme, pour tous les nœuds de l'ensemble passé en argument, du résultat de la
conversion en numérique de leur valeur textuelle. Si un ou plusieurs nœuds
sélectionnés ne sont pas convertibles la fonction renverra NaN. Attention de ne pas
oublier que la conversion d'un nœud vide n'est pas zéro mais NaN.
Exemple 1 :
Dans le fichier XML : <notes><note>14.5</note><note>13.5</note><note>17</note></notes>
Dans le fichier XSL :
<xsl:template match="notes">
La moyenne des notes : <b><xsl:value-of select="sum(./note) div count(./note)" /></b>
</xsl:template>
Exemple 2 :
Dans le fichier XML : <rectangle cotegauche="15" cotedroite="15" cotehaut="30" cotebas="30" />
Dans le fichier XSL :
<xsl:template match="rectangle">
Le périmètre du <b><xsl:value-of select="name()" /></b> : <xsl:value-of select="sum(@*)" />cm
</xsl:template>

♦ Fonctions de chaînes :
▪ string(…) : convertit le paramètre en chaîne. Le paramètre peut être un nombre ou un
ensemble de nœuds. Ce dernier est converti en chaîne de caractères en retournant la
valeur textuelle du premier nœud de l'ensemble passé en argument. Si l'ensemble de
nœuds est vide, une chaîne vide est retournée.
▪ string-length(…) : retourne la longueur d'une chaîne donné comme paramètre. Si
l'argument est omis, la valeur retournée est égale à la longueur de valeur textuelle du
nœud en lecture.
▪ concat(…, …[, …]*) : permet la concaténation de plusieurs chaînes.
Exemple :
string(1234) : <xsl:value-of select="string(1234)"/><br />
string(annuaire/personne/nom) : <xsl:value-of select="string(annuaire/personne/nom)"/><br />
string-length('Web') : <xsl:value-of select="string-length('Web')"/><br />
concat(..) : <xsl:value-of select="concat('La personne dont le nom est ', annuaire/personne/nom,
' a le numéro : ', annuaire/personne/telephone)" />

▪ normalize-space(chaine) : retourne la chaîne de caractères chaine après en avoir
supprimé les espaces situés au début et à la fin, et y avoir remplacé chaque séquence
d'espaces consécutifs par un espace unique.
▪ contains(chaine1, chaine2) : permet de tester si la chaîne de caractères chaine1 contient
la chaîne de caractères chaine2. Ex.: contains("chaine", "ne") retourne true mais
contains("chaine", "Ne") retourne false.
▪ starts-with(chaine1, chaine2) : permet de tester si chaine1 commence par chaine2. Ex. :
starts-with("Ceci est une chaîne", "Ceci") retourne true.
Remarque : Toutes les fonctions de manipulation de chaînes de caractères sont sensibles
à la casse.
Exemple :
<p>
<xsl:if test="starts-with(normalize-space(.),'Zrouri')">
<b><xsl:value-of select="." /></b>
</xsl:if>
<xsl:if test="contains(prenom,'R')">
<mark><xsl:value-of select="." /></mark>
</xsl:if>
</p>
</xsl:template>
XSL : Transformation vers d’autres
formats
♦ L'élément <xsl:output> indique, quel type de résultat le processeur doit générer. Trois formats de
résultats sont possibles : XML, HTML et texte. La sortie standard de XSLT est XML, sauf si
une balise <html> se trouve dans le document, alors HTML sera généré.
♦ Syntaxe :
<xsl:output method="html|xml|text" [version="…" encoding="…" doctype-system="…"
doctype-public="…" omit-xml-declaration="yes|no"] />
Remarques :
- version définit la valeur de l'attribut version dans la déclaration XML ou HTML du document de
sortie. Cet attribut n'est utilisé qu'avec method="html" ou method="xml".
- doctype-system spécifie l'identifiant système qui doit être utilisé dans la déclaration de la DTD
respectée par le document résultat (le processeur ajoutera de lui même la ligne DOCTYPE qui
convient).
- doctype-public spécifie l'identifiant public qui doit être utilisé dans la déclaration de type de
document.
- omit-xml-declaration indique d'inclure ou non, une déclaration XML dans le document de sortie.
♦ L’élément <xsl:output> doit être l'enfant de <xsl:stylesheet> (élément de haut niveau).
formats
♦ Exemple 1: Cette feuille de style transforme notre document XML «annuaire.xml»
présenté en exemple précédent en un autre document XML entièrement basé sur des
attributs :
<xsl:output method="xml" />
<annuaire> <xsl:apply-templates select="annuaire/personne"/> </annuaire>
</xsl:template>
Ou : <xsl:template match="personne">
<xsl:template match="personne"> <personne nom="{nom}" prenom="{prenom}" telephone="{telephone}" />
<personne> </xsl:template>
<xsl:attribute name="nom"><xsl:value-of select="nom" /></xsl:attribute>

<xsl:attribute name="prenom"><xsl:value-of select="prenom" /></xsl:attribute>
<xsl:attribute name="telephone"><xsl:value-of select="telephone" /></xsl:attribute>
</personne>
</xsl:template>
</xsl:stylesheet>
formats
♦ Exemple 2: Cette feuille de style transforme notre document XML «annuaire.xml» en un
autre document XML possédant comme élément racine document et comme éléments
enfants titre et personnes :
<xsl:output method="xml" />
<document>
<titre>Annuaire</titre>
<personnes>
Les trois personnes sont : <xsl:apply-templates select="annuaire/personne" />
</personnes>
</document>
</xsl:template>
<xsl:value-of select="." />
<xsl:if test="position()<last()-1">, </xsl:if><xsl:if test="position()=last()-1"> et </xsl:if>
<xsl:if test="position()=last()">.</xsl:if></xsl:template></xsl:stylesheet>

formats
♦ Exemple 3: Cette feuille de style transforme notre document XML «annuaire.xml» en un
document texte :
<xsl:output method="text" omit-xml-declaration="yes" />
<xsl:apply-templates select="annuaire/personne" />
</xsl:template>
<xsl:value-of select="nom" /><xsl:text> </xsl:text>
<xsl:value-of select="prenom" /><xsl:text> a le numéro : </xsl:text>
<xsl:value-of select="telephone" /><xsl:text>|
</xsl:text>
</xsl:template>
</xsl:stylesheet>
XSL : Priorité implicite et explicite
♦ Les règles implicites (ou "par défaut" : default rules) :
▪ Les règles implicites, qui s'appliquent en l'absence de règle applicable à un nœud,
provoquent un parcours récursif de l'arbre en profondeur d'abord, envoyant en sortie le
contenu textuel de l'arbre tout entier (concaténation des contenus de tous ses sommets,
dans l'ordre du parcours).
▪ Par conséquent, la feuille de style vide fait quelque chose : elle extrait le contenu textuel
du fichier source.
Exemple : Si on applique au fichier annuaire.xml (voir premier exemple de ce chapitre)
la feuille de style suivante :
</xsl:stylesheet>
▪ Pour obtenir l'inaction totale, il faut donc inhiber ce fonctionnement par défaut, et pour
cela écrire une règle applicable au nœud racine (filtre = "/"). En effet, lorsqu'une règle
est applicable à un nœud, elle inhibe l'effet de la "propagation par défaut" aux fils du
nœud en question.
♦ Priorité des règles et résolution des conflits :
Il arrive fréquemment - ne serait-ce qu'en raison de la présence des règles implicites -
que plusieurs règles puissent s'appliquer à un même élément. En ce cas, l'interprète XSLT
en choisira une seule et il l'appliquera. Le choix de l'interprète repose sur une notion de
priorité : la règle choisie sera celle qui a la plus haute priorité parmi les règles applicables.
Remarque : L’ordre d'écriture des templates est sans importance.
▪ Priorité explicite : au moyen de l'attribut priority , à valeur numérique.

Exemple :
La règle <xsl:template match="monElem" priority="2">... </xsl:template>
est prioritaire par rapport à la règle :
<xsl:template match="monElem" priority="1">… </xsl:template>
Remarque :
La valeur de l’attribut priority peut être un nombre "flottant", et même négatif. Les
priorités implicites vont de -0.5 à 0.5.

▪ Priorité implicite :
- Les règles exprimées explicitement sont prioritaires par rapport aux règles implicites. Il
suffit donc d'écrire une règle pour que les règles implicites qui lui feraient concurrence
soient rejetées.
- Il y a exactement quatre niveaux de priorités implicites, par ordre de priorité croissante :
1- filtres anonymes sans préfixe d’espace de noms, comme "*", ou "text()" :
priorité = -0.5
2- filtres anonymes avec préfixe d’espace de noms, comme "monpréfixe:*" :
priorité = -0.25
3- filtres comportant seulement un nom, avec ou sans préfixe d’espace de noms,
comme "personne" ou "monpréfixe:personne" :
priorité = 0
4- tout autre filtre, c'est-à-dire dès qu'apparaît un cheminement '/' ou un prédicat
entre '[' et ']' :
priorité = 0.5
Remarque : Si deux règles s'appliquant à un même élément ont la même priorité, le
processeur applique la règle qui apparaît en dernière position dans la feuille de style.

Chapitre3 XMLetXSL

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre3 XMLetXSL

Transféré par

Droits d'auteur :

Formats disponibles

Développement Web

Chapitre 3 : XML / XSL

25/12/2023 Prof. Hafida ZROURI 3

25/12/2023 Prof. Hafida ZROURI 4

25/12/2023 Prof. Hafida ZROURI 5

3- On peut aussi trouver des instructions de traitement au début du document qui

25/12/2023 Prof. Hafida ZROURI 6

♦ Chaque document contient un et un seul élément englobant tous les autres

♦ Tout élément fils est complètement inclus dans son père.

25/12/2023 Prof. Hafida ZROURI 7

25/12/2023 Prof. Hafida ZROURI 8

♦ Un élément vide est un élément ne possédant pas de contenu c'est-à-dire lorsque la

25/12/2023 Prof. Hafida ZROURI 9

25/12/2023 Prof. Hafida ZROURI 10

♦ Ils peuvent être présents dans le prologue et en particulier dans la DTD,

♦ Ils ne peuvent jamais apparaître à l'intérieur d'une balise ouvrante ou

25/12/2023 Prof. Hafida ZROURI 11

Les autres entités de caractères couramment utilisées en HTML (&nbsp;

25/12/2023 Prof. Hafida ZROURI 12

25/12/2023 Prof. Hafida ZROURI 14

25/12/2023 Prof. Hafida ZROURI 15

25/12/2023 Prof. Hafida ZROURI 16

25/12/2023 Prof. Hafida ZROURI 19

25/12/2023 Prof. Hafida ZROURI 20

5. Élément avec des éléments enfants en alternatif :

25/12/2023 Prof. Hafida ZROURI 21

7. Élément avec un contenu mixte :

25/12/2023 Prof. Hafida ZROURI 22

25/12/2023 Prof. Hafida ZROURI 24

25/12/2023 Prof. Hafida ZROURI 25

<?xml version="1.0" encoding="UTF-8"?>

25/12/2023 Prof. Hafida ZROURI 28

25/12/2023 Prof. Hafida ZROURI 29

25/12/2023 Prof. Hafida ZROURI 30

25/12/2023 Prof. Hafida ZROURI 32

25/12/2023 Prof. Hafida ZROURI 33

25/12/2023 Prof. Hafida ZROURI 34

♦ Voici quelques espaces de noms classiques :

25/12/2023 Prof. Hafida ZROURI 35

25/12/2023 Prof. Hafida ZROURI 37

25/12/2023 Prof. Hafida ZROURI 38

25/12/2023 Prof. Hafida ZROURI 39

25/12/2023 Prof. Hafida ZROURI 43

25/12/2023 Prof. Hafida ZROURI 44

25/12/2023 Prof. Hafida ZROURI 45

♦ Le principe de fonctionnement de XSL est le suivant :

25/12/2023 Prof. Hafida ZROURI 49

25/12/2023 Prof. Hafida ZROURI 50

25/12/2023 Prof. Hafida ZROURI 51

25/12/2023 Prof. Hafida ZROURI 52

- Applique l’ensemble des règles aux nœuds atteints par chemin

25/12/2023 Prof. Hafida ZROURI 53

25/12/2023 Prof. Hafida ZROURI 54

25/12/2023 Prof. Hafida ZROURI 55

Le processeur commence la transformation en cherchant une template pour la racine

25/12/2023 Prof. Hafida ZROURI 56

La transformation commence de la même manière : la règle correspondant à la racine

25/12/2023 Prof. Hafida ZROURI 58

25/12/2023 Prof. Hafida ZROURI 59

25/12/2023 Prof. Hafida ZROURI 61

25/12/2023 Prof. Hafida ZROURI 62

25/12/2023 Prof. Hafida ZROURI 64

25/12/2023 Prof. Hafida ZROURI 67

Les autres entités de caractères couramment utilisées en HTML (