Introduction au langage XML

3: XSLT et programmation avec XML (modèle

DOM et SaX)

XSL : Introduction

XSLT: eXtensible Stylesheet Language

Version 1.0
W3C Recommandation du 16 novembre 1999
XSL est l'héritier de DSSSL (scheme (lisp) manipulant du
SGML).
La communauté DSSSL souhaitait un langage
permettant le traitement des sources pour imprimer
différentes versions:
voulait une puissance d'un langage de programmation sans
prendre en compte l'interactivité sur la version finale (retour des
évènements?)

Page 1
XSL : caractéristiques

Un langage de manipulation d'arbres

Change un dialecte XML en un autre
Langage déclaratif basé sur la recherche de motifs dans un
arbre
Transformation dirigée par le document
Pas vraiment un langage de formatage
Un langage de réécriture pour XML subdivisé en:
XSLT (Transformation) : est un langage permettant de produire
un document XML ou texte a partir d'un autre document par
application de règles de transformation
XSL-FO (Formatting Object): est une DTD XML qui définie la
présentation d'un texte sur un document papier (PS, GV,
PDF,DPS).
Utilise XPath pour la localisation des noeuds

XSLT : Principe

Un document XML + une feuille de style XSL ->

processeur XSLT -> un document XML (ou autre
format de sortie, HTML, ...)
Analyse un document XML
Trouve les noeuds sur l'arbre en mémoire (DOM)
correspondant aux règles XSL
Génère un nouvel arbre DOM à partir des instructions
de ces règles
"Imprime" le XML résultant

Page 2
XSLT : Principe (2)

XSL joue un rôle de pivot entre document original

et celui de sortie

XSLT : syntaxe de la feuille de style

Une feuille de style XSL est un document XML

<?xml version="1.0" encoding="iso-8859-1" ?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0" id="identifiant" extension-element-
prefixes="liste"
exclude-result-prefixes="liste" >
... déclarations optionnelles ...
... règles de transformation ...
</xsl:stylesheet>

Page 3
XSLT : format de sortie

Déclaration optionnelle du format de sortie

<xsl:output
method="xml|html|text|nom"
version="version"
encoding="type_encodage"
omit-xml-declaration="yes|no"
standalone="yes|no"
doctype-public="identifiant"
doctype-system="identifiant"
cdata-section-elements= "liste de nom"
indent="yes|no"
media-type="type"/>
A mettre au début du fichier (après xsl:stylesheet)

XSLT : format de sortie (2)

Output en HTML: Output en XHTML
<xsl:output method="html" <xsl:stylesheet version="1.0"
encoding="ISO-8859-1" xmlns:xsl="http://www.w3.org/1999/XSL/Transfor
doctype-public="-//W3C//DTD m" xmlns="http://www.w3.org/TR/xhtml1/strict">
HTML 4.01 Transitional//EN"/> <xsl:output method="xml" doctype system=
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd"
doctype-public="-//W3C//DTD XHTML 1.0
Output en SVG Transitional//EN"
<xsl:output indent="yes"
method="xml" encoding="iso-8859-1"
indent="yes"
standalone="no"
doctype-public="-//W3C//DTD SVG 1.0//EN"
Doctype-system="http://www.w3.org/TR/2001/PR-SVG 20010719/DTD/svg10.dtd"
media-type="image/svg"

Page 4
XSLT : éléments du premier niveau
Les éléments du premier niveau d’une feuille XSL

xsl:attribute-set Définit un groupe d’attributs

xsl:decimal-format Définit un format d’affichage pour les numériques
xsl:import Importe d’un programme XSLT
xsl:include Inclusion d’un programme XSLT
xsl:key Définit une clé pour un groupe de noeuds
xsl:namespace-alias Définit des alias pour certains espaces de nom
xsl:output Indique le format de sortie (HTML, XML, texte)
xsl:param Définit un paramètre
xsl:preserve-space Conserve les noeuds blancs (noeuds constitué
uniquement d’espaces) pour certains éléments
xsl:strip-space Supprime les noeuds blancs pour certains éléments
xsl:template Définit une règle XSLT
xsl:variable Définit une variable XSLT

XSLT : Modularité - import et include

XSLT fournit deux éléments de premier niveau

pour intégrer des fichiers afin de constituer des
programmes modulaires: xsl:import et xsl:include
L’assemblage de plusieurs programmes peut
créer des conflits. Au moment de l’évaluation
plusieurs règles peuvent s’appliquer aux mêmes
noeuds. Afin de déterminer la règle à appliquer,
XSLT utilise un système de priorités (pour
xsl:import principalement)

10

Page 5
XSLT : Modularité - import et include (2)

Importation de feuilles XSL avec gestion de la

priorité :
<xsl:import href="URL_de_la_feuille_XSL" />
Les règles importées sont moins prioritaires que les
règles définies dans la feuille courante.
Cette déclaration doit figurer en tête d'une feuille de
style
Inclusion de feuilles XSL (aucun impact sur la
priorité)
<xsl:include href="URL_de_la_feuille_XSL" />

11

XSLT : Modularité - import et include (3)

Points différents entre xsl:import et xsl:include

dans le cas de xsl:import le processeur affecte aux
règles importées une préséance inférieure à celle du
programme importateur ; dans le cas de xsl:include,
les règles importées sont traitées de ma même façon
que celle des règles locales
xsl:import doit apparaître avant tout autre élément de
premier niveau dans un programme XSLT; xsl:include
peut apparaître au corps du programme

12

Page 6
XSLT : Modularité - import et include (4)
Exemple cours.xml
<?xml version=’1.0’ encoding="ISO-8859-1"?>
<COURS UE="TC2.1">
<SUJET>XML et outils GL</SUJET>
<ENSEIGNANTS>
<!-- Enseignant responsable -->
<NOM>Le Thanh</NOM>
<NOM>Huet</NOM>
</ENSEIGNANTS>
<PROGRAMME>
<SEANCE ID="1">Documents XML</SEANCE>
<SEANCE ID="2">Programmation XSLT</SEANCE>
<SEANCE ID="3">XML SCHEMA</SEANCE>
<ANNEE>0506</ANNEE>
</PROGRAMME>
</COURS>

13

XSLT : Modularité - import et include (5)

Exemple : prog1.xsl
<?xml version="1.0" </title>
encoding="ISO-8859-1"?> </head>
<xsl:stylesheet version="1.0" <body bgcolor="white">
xmlns:xsl="http://www.w3.org/199 <xsl:apply-templates/>
9/ XSL/Transform"> </body>
<xsl:strip-space elements="*"/> </html>
<xsl:template match="/"> </xsl:template>
<html> </xsl:stylesheet>
<head>
<title>
<xsl:value-of
select="COURS/SUJET"/>

14

Page 7
XSLT : Modularité - import et include (6)

Le document HTML produit par prog1.xsl

<html>
<head>
<META http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title>Publication XSLT</title>
</head>
<body bgcolor="white"></body>
</html>
15

XSLT : Modularité - import et include (7)

Exemple principal.xml
<?xml version="1.0" encoding="ISO-8859- Ce programme qui affiche la liste
1"?> des enseignants du cours :
<xsl:stylesheet version="1.0" Il commence par importer le fichier
xmlns:xsl="http://www.w3.org/1999/XSL prog1.xsl, ce qui dispense de définir
/Transform"> une règle s’appliquant à la racine du
<xsl:import href=« prog1.xsl"/> document.
<xsl:template Ensuite on redéfinit les règles
match="COURS/ENSEIGNANTS"> s’appliquant au sous-arbre des
<ol><xsl:apply-templates enseignants
select="NOM"/></ol>
pour produire une liste avec les noms.
</xsl:template>
Ces règles ont une préséance
<xsl:template match="NOM">
supérieure à celles du fichier importé
<li><xsl:value-of select="."/></li>
qui ne produisaient aucun résultat.
</xsl:template>
</xsl:stylesheet>

16

Page 8
XSLT : Modularité - import et include (8)
La règle de préséance se
généralise assez simplement à
l’importation de plusieurs
documents de la manière
suivante :
si un document D1 est importé
avant un document D2, alors
toutes les règles de D2 ont une
préséance supérieure à celles
de D1
si une règle r1 a une
préséance supérieure à r2,
elle-même supérieure à r3,
alors r1 a une préséance
supérieure à r3 ( transitivité)

17

XSLT : Règle de transformation

Le corps d’une feuille de style (stylesheet) est une

succession de règles de réécriture: les xsl:template
partie gauche: motif qui identifie la partie du document sur
laquelle va s'appliquer la règle (XPath)
partie droite: description d'une action qui définit la transformation
à appliquer sur un noeud
une règle "template" permet de sélectionner un noeud de l'arbre
XML pour un traitement (transformation)
"match = <expression XPath>" définit le noeud à sélectionner
Les noeuds peuvent être définis par un chemin complet (pour
définir des contextes)

18

Page 9
XSLT : Règle de transformation (2)

Exemple :
<xsl:stylesheet>
<xsl:template match="/">
[action]
</xsl:template>
<xsl:template match="livre">
[action]
</xsl:template>
...
</xsl:stylesheet>

19

XSLT : Règle de transformation (3)

Déclaration générale du format de template :

<xsl:template
match="pattern_XPATH"
mode="mode" priority="nombre" >
... element(s) de remplacement ...
</xsl:template>
Le pattern XPATH est une ou plusieurs
expressions XPATH connectées par un ou « | »

20

Page 10
 XSLT : Règle de transformation (4)
Le fichier XSL exemple.xsl
<?xml version="1.0"?>
Exemple <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Le fichier XML <xsl:template match="page">
<?xml version="1.0" <html> <head> <title> <xsl:value-of select="title"/> </title> </head>
<body bgcolor="#ffffff">
encoding="ISO-8859-
<xsl:apply-templates/>
1"?> </body>
<?xml-stylesheet </html>
href=« exemple.xsl" </xsl:template>
type="text/xsl"?> <xsl:template match="title">
<article> <h1 align="center"> <xsl:apply-templates/> </h1>
<title> </xsl:template>
Introduction à XLM </title> <xsl:template match=« resume">
<resume> <p align="center"> <xsl:apply-templates/> </p>
un tutorial pratique de XML </xsl:template>
</resume> <xsl:template match=« Auteur">
<auteur> <hr /> Auteur: <xsl:apply-templates/>
Dupont </auteur> </xsl:template>
</article> </xsl:stylesheet>

21

XSLT : Règle de transformation (5)

Exemple (suite)
Le "fichier" XHTML résultant que l’on désire obtenir
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.0//EN" "http://www.w3.org/TR/REChtml40/strict.dtd">
<html>
<head><title>Introduction à XLM</title></head>
<body bgcolor="#ffffff">
<h1 align="center">Introduction à XLM </h1>
<p align="center"> Un tutorial pratique </p>
<hr> Auteur : Dupont
</body>
</html>

22

Page 11
 XSLT : Règle de transformation (6)

Le déclenchement d’une règle de transformation

définie avec xsl:template est fait soit par
xsl:apply-templates soit par xsl:call-template
Une règle peut être déclenchée ou instanciée soit
par son nom, soit en donnant la catégorie des
noeuds du document source auxquels elle
s’applique
Cette catégorie de noeuds est spécifiée par une
sous-classe des expressions XPath désignée par
le terme pattern
23

XSLT : Règle de transformation (7)

Les patterns : Le programme suivant recherche et affiche les noms
des enseignants, les attributs ID et l’intitulé des séances de cours :
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="ISO-8859-1"/>
<xsl:template match="/"> <xsl:apply-templates select="//NOM"/>
<xsl:apply-templates select="//SEANCE/@ID"/>
<xsl:apply-templates select="//SEANCE"/> </xsl:template>
<xsl:template match="NOM"> <NOM> <xsl:value-of select="."/></NOM> </xsl:template>
<xsl:template match="@ID"> <IDSEANCE><xsl:value-of select="."/></IDSEANCE>
</xsl:template>
<xsl:template match="PROGRAMME/SEANCE">
<SEANCE><xsl:value-of select="."/></SEANCE> </xsl:template>
</xsl:stylesheet>

24

Page 12
XSLT : Règle de transformation (8)
Rappel de l’exemple cours.xml
<?xml version=’1.0’ encoding="ISO-8859-1"?>
<COURS UE="TC2.1">
<SUJET>XML et outils GL</SUJET>
<ENSEIGNANTS>
<!-- Enseignant responsable -->
<NOM>Le Thanh</NOM>
<NOM>Huet</NOM>
</ENSEIGNANTS>
<PROGRAMME>
<SEANCE ID="1">Documents XML</SEANCE>
<SEANCE ID="2">Programmation XSLT</SEANCE>
<SEANCE ID="3">XML SCHEMA</SEANCE>
<ANNEE>0506</ANNEE>
</PROGRAMME>
</COURS>

25

XSLT : Règle de transformation (9)

Le résultat du programme XSL sur cours.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<NOM>Le Thanh</NOM>
<NOM>Huet</NOM>
<IDSEANCE>1</IDSEANCE>
<IDSEANCE>2</IDSEANCE>
<IDSEANCE>3</IDSEANCE>
<SEANCE>Documents XML</SEANCE>
<SEANCE>Programmation XSLT</SEANCE>
<SEANCE>XML SCHEMA </SEANCE>

26

Page 13
XSLT : Règle de transformation (10)

Les expressions Xpath dans l’exemple apparaissent

comme
valeur de l’attribut match de l’élément xsl:template,
d’autres comme valeur de l’attribut select de xsl:apply-
templates.
Elles jouent un rôle différent
l’expression dans l’élément xsl:apply-templates sert à désigner
un ensemble de noeuds, et constitue donc une utilisation
classique de XPath ;
l’expression dans l’élément xsl:template exprime en revanche
une condition sur les noeuds qui vont permettre de déclencher la
règle.

27

XSLT : Règle de transformation (11)

Conclusion :
un pattern dans une règle définit la « situation » des noeuds de
l’arbre qui vont pouvoir déclencher la règle.
Cette situation peut être très générale : un pattern NOM définit
une règle applicable à tous les éléments de type NOM, quel que
soit leur position, et quel que soit le type de leurs parents.
Un pattern comme PROGRAMME/SEANCE est déjà plus
restrictif.
À l’extrême, un pattern peut être un chemin absolu XPath, et la
règle ne s’applique plus alors qu’à des sous-arbres très
particuliers.

28

Page 14
XSLT : Règle de transformation (12)

Conclusion (suite) :
Les patterns sont des expressions XPath dont
l’interprétation consiste à chercher un noeud
contexte à partir duquel le résultat du pattern
contient le noeud courant. Ceci a deux
conséquences :
l’expression pattern doit toujours retourner un ensemble de
noeuds (node-set) ;
la recherche du noeud contexte peut devenir très complexe si on
acceptait n’importe quelle expression XPath donnant un
ensemble de noeuds : il faudrait, dans certains cas, pour vérifier
si un noeud satisfait une expression, chercher un noeud contexte
adapté parmi tous les noeuds du document source.

29

XSLT : Règle de transformation (13)

Algorithme d’évaluation d’un parttern P à partir d’un

nœud courant N :
Cet algorithme fait d’abord une distinction entre le cas d’un
pattern absolu et le cas d’un pattern relatif :
Si P est absolu, prendre la racine comme nœud contexte et
évaluer P ; si N fait partie du résultat, alors P satisfait
Sinon
(a) prendre N comme nœud contexte et évaluer P; si N fait partie du
résultat, alors P satisfait;
(b) sinon prendre le père de N et recommencer l’évaluation ; si N fait
partie du résultat, alors P satisfait;
(c) sinon recommencer en parcourant les ancêtres de N jusqu’à la
racine du document.

30

Page 15
XSLT : Règle de transformation (14)

Exemples :
le pattern absolu /COURS/ENSEIGNANTS sera satisfait par tous
les nœuds de type ENSEIGNANTS fils d’un élément racine de
type COURS ;
//SEANCE[@ID=2] ou SEANCE[@ID=2] seront satisfait par tout
nœud de type SEANCE ayant un attribut ID valant 2 (vérifiez
l’équivalence des deux expressions)
NOM[position()=2] sera satisfait par tout nœud qui est le
deuxième fils de type NOM de son père ;
*[position()=2][name()="NOM"] sera satisfait par tout nœud de
type NOM, second fils de son père ;
/COURS/@UE[.="TC2.1"] sera satisfait par l’attribut UE, fils de
l’élément racine COURS et dont la valeur est TC2.1

31

XSLT : Règle de transformation (15)

Une règle est définie par un élément de premier

niveau xsl:template. Cet élément comprend :

Des attributs qui décrivent les conditions de

déclenchement de la règle, et

un contenu ou corps de règle décrivant le texte à

produire quand la règle est déclenchée (ou «
instanciée » pour utiliser le vocabulaire XSLT).

32

Page 16
XSLT : Règle de transformation (16)

Les quatre attributs d’une règle sont les suivants :

match est le pattern désignant les nœuds de l’arbre
XML pour lesquels la règle peut se déclencher ;
name définit une règle nommée qui pourra être
appelée directement par son nom ;
mode permet de définir des catégories de règles, à
appeler dans des circonstances particulières ;
priority donne une priorité explicite à la règle.
Tous les attributs sont optionnels, mais soit
name, soit match doit être défini.

33

XSLT : Règle de transformation (17)

Règles par défaut : XSLT définit un ensemble de règles
par défaut qui sont appliquées quand aucune règle du
programme n’est sélectionnée
La première règle par défaut s’applique à la racine du document
et à tous les éléments.
La seconde règle par défaut s’applique aux nœuds de texte et
aux attributs. Elle insère le contenu textuel de ces nœuds dans
le document résultat

1ère règle 2e règle

<xsl:template match="* | /"> <xsl:template match="text() | @*">
<xsl:apply-templates/> <xsl:value-of select="."/>
</xsl:template> </xsl:template>

34

Page 17
XSLT : Règle de transformation (18)
Règles par défaut (suite) :
Enfin la dernière règle par défaut s’applique aux
commentaires et aux instructions de traitement. Le
comportement par défaut est de les ignorer. La règle
ne fait donc rien :
<xsl:template match="processing-instruction() | comment()"/>
Exemple : programme xsl minimal

<?xml version="1.0" encoding="ISO-8859-1"?>

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

35

XSLT : Règle de transformation (19)

L’application de ce programme à notre document

CoursXML.xml donne le résultat suivant :
<?xml version="1.0" encoding="UTF-
8"?>
XML et outils GL
Le Thanh
Huet
Documents XML
Programmation XSLT
XLM SCHEMA
0506
36

Page 18
XSLT : Règle de transformation (20)
Déclenchement de règles avec xsl:apply-templates : Cet
élément a deux attributs, tous deux optionnels :
select contient l’expression XPath désignant les nœuds à traiter ;
mode est la catégorie des règles à considérer

L’expression de l’attribut select doit toujours ramener un

ensemble de nœuds. Sa valeur par défaut est
child::node(), autrement dit tous les fils du nœud courant,
quel que soit leur type, à l’exception comme d’habitude
des attributs

37

XSLT : Règle de transformation (21)

Exemple :
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="ISO-8859-1"/>
<xsl:template match="/">
<xsl:apply-templates select="//ENSEIGNANTS"/>
</xsl:template>
<xsl:template match="ENSEIGNANTS">
<xsl:comment>
Application de la règle ENSEIGNANTS
</xsl:comment>

38

Page 19
XSLT : Règle de transformation (22)
Exemple (suite) :
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="NOM">
<xsl:value-of select="position()"/> : Noeud NOM
</xsl:template>
<xsl:template match="text()">
<xsl:value-of select="position()"/> : Noeud de texte
</xsl:template>
<xsl:template match="comment()">
<xsl:value-of select="position()"/> : Noeud de commentaire
</xsl:template>
</xsl:stylesheet>

39

XSLT : Règle de transformation (23)

Résultat du programme précédent
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--
Application de la règle ENSEIGNANTS
-->
1 : Noeud de texte
2 : Noeud de commentaire
3 : Noeud de texte
4 : Noeud NOM
5 : Noeud de texte
6 : Noeud NOM
7 : Noeud de texte

40

Page 20
XSLT : Instructions

L’exécution d’un programme XSLT consiste à déclencher

(ou instancier) des règles définies par des éléments de
premier niveau xsl:template.
L’instanciation d’une règle consiste à produire un
fragment du document résultat en fonction d’éléments
littéraux, de texte et d’instructions XSLT constituant le
corps de règle :
Les éléments littéraux et texte sont insérés directement au
résultat
les instructions XSLT sont interprétées par le processeur XSLT

41

XSLT : Instructions (2)

Exemple : création d’une éléments littéraux :

liste HTML avec les séances balises <h3>, <ol>, <li>
d’une salle de cinéma
nœuds de type Text :
le noeud fils de <h3> est
<h3>Séances</h3>
une chaîne de caractères
<ol>
<xsl:for-each
Instructions dont le nom
select="SEANCES/SEANCE"> préfixé par xsl:
<li><xsl:value-of select="."/></li> xsl:for-each
</xsl:for-each> xsl:value-of

</ol>

42

Page 21
XSLT : Instructions (3)
Liste d’instruction XSL
xsl:apply-imports Permet d’appliquer une règle importée, tout en la
complétant par un nouveau corps
xsl:apply-templates Déclenche l’application de règles
xsl:attribute Insère un attribut dans un élément du document
résultat
xsl:call-template Appelle une règle par son nom
xsl:choose Structure de test équivalente au switch d’un langage
comme Java ou C++
xsl:comment Insère un noeud Comment dans le document résultat
xsl:copy Copie un noeud du document source dans le document
résultat
xsl:copy-of Copie un noeud, ainsi que tous ses descendants
xsl:result-document Permet de créer plusieurs documents résultats : ajouté
dans XSLT 2.0, mais reconnu par la plupart de processeurs
XSLT actuels, éventuellement sous un autre nom

43

XSLT : Instructions (4)

Liste d’instruction XSL (suite)
xsl:element Insère un noeud Element dans le document résultat
xsl:fallback Règle déclenchée si le processeur ne reconnaît pas une
instruction
xsl:for-each Pour effectuer des itérations
xsl:if Pour effectuer un branchement conditionnel
xsl:message Pour produire un message pendant le traitement XSLT
xsl:number Permet de numéroter les noeuds du document résultat
xsl:variable Permet de définir un paramètre
xsl:processing-instruction Insère un noeud ProcessingInstruction dans le
document résultat
xsl:text Insère un noeud Text dans le document résultat
xsl:value-of Évalue une expression XPath et insère le résultat
xsl:variable Permet de définir une variable

44

Page 22
XSLT : évaluation d’un programme
<?xml version="1.0" encoding="ISO-8859-1"?> <ol>
<xsl:stylesheet version="1.0" <xsl:apply-templates select="NOM"/>
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> </ol>
<xsl:output method="html" encoding="ISO-8859-1"/> </xsl:template>
<xsl:template match="/"> <xsl:template match="PROGRAMME">
<html> <h1>Programme</h1>
<head> <ul>
<title><xsl:value-of select="COURS/SUJET"/></title> <xsl:for-each select="SEANCE">
</head> <xsl:call-template name="AfficheSeance"/>
<body bgcolor="white"> </xsl:for-each>
<xsl:apply-templates/> </ul>
</body> </xsl:template>
</html> <xsl:template match="ENSEIGNANTS/NOM">
</xsl:template> <li><xsl:value-of select="." /></li>
<xsl:template match="SUJET"> </xsl:template>
<h1><center><xsl:value-of <xsl:template name="AfficheSeance">
select="."/></center></h1> <li> Séance <xsl:value-of select="concat(
</xsl:template> position(), ’/’, last(), ’ : ’, . )"/>
<xsl:template match="ENSEIGNANTS"> </li>
<h1>Enseignants</h1> </xsl:template>
</xsl:stylesheet>

45

XSLT : évaluation d’un programme (2)

Début de l’évaluation : le Après instanciation de la

document résultat première règle

46

Page 23
XSLT : évaluation d’un programme (3)
Après évaluation de xsl:value-of

XML et Outils GL

47

XSLT : évaluation d’un programme (4)

Après évaluation de xsl:apply-templates

XML
XMLetetOutils
OutilsGL
GL

48

Page 24
XSLT : évaluation d’un programme (5)

Après évaluation du xsl:for-each

XML & GL
xsl:call-template
xsl:call-template
name=”AfficheSeance”
name=”AfficheSeance”
(courant
(courant :: SEANCE[3])
SEANCE[3])
Le Thanh Huet

49

XSLT : évaluation d’un programme (6)

Le résultat final

XML & GL

Séance
Séance 3/3
3/3 ::
Le Thanh Huet XML SCHEMA
XML SCHEMA

3 3

50

Page 25
XSLT : évaluation d’un programme (7)
le document HTML résultat <ol>
<html> <li>Le Thanh</li>
<head> <li>Huet</li>
<META http-equiv="Content- </ol>
Type" content="text/html; <h1>Programme</h1>
charset=ISO-8859-1">
<ul>
<title>XML et Outils GL</title>
<li> S&eacute;ance 1/3 :
</head> Documents XML</li>
<body bgcolor="white"> <li> S&eacute;ance 2/3 :
<h1> Programmation XSLT</li>
<center> title>XML et Outils GL <li> S&eacute;ance 3/3 : XML
</center> SCHEMA</li>
</h1> </ul>
<h1>Enseignants</h1> </body> </html>

51

Programmation avec XML : introduction

Les deux principales interfaces de

programmation (API) XML depuis différents
langages :
DOM (Document Object Model), basé sur une
représentation arborescente
SaX (Simple API for XML), basé sur des déclencheurs
“événement/action”
On a pces API pour les différents langages :
Java, Javascript, PhP, Perl, Python, C++, C#, …

52

Page 26