Manuel INF 6450 (complet) - Téluq

Manuel INF 6450 (complet) 

Daniel Lemire, professeur responsable 

Kamel Aouiche, auxiliaire de recherche 

Lucie Moulet, auxiliaire de recherche 

Jean-François Savard, concepteur associé 

Renée Dumas, spécialiste en communication écrite 

Montréal, 4 avril 2009

Sommaire 

Sommaire 

iii 

Guide d’étude 1 

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 

Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 

Contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

Découplement des informations . . . . . . . . . . . . . . . . 3 

XML et interopérabilité . . . . . . . . . . . . . . . . . . . . 3 

Flexibilité et évolution des schémas de données . . . . . . . . 4 

Les modules du cours . . . . . . . . . . . . . . . . . . . . . . . . . . 5 

Caractéristiques médiatiques . . . . . . . . . . . . . . . . . . . . . . 6 

Encadrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 

L’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

Les travaux notés . . . . . . . . . . . . . . . . . . . . . . . 7 

Examen en salle . . . . . . . . . . . . . . . . . . . . . . . . 8 

Gestion du temps et pondération . . . . . . . . . . . . . . . . . . . . 8 

Version PDF du cours . . . . . . . . . . . . . . . . . . . . . . . . . . 10 

Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

Module 1 : Introduction à XML 13 

1.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

1.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

1.1.2 Qu’est-ce que le XML . . . . . . . . . . . . . . . . . . . . . 13 

1.1.3 Démarche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

1.2 Installation de Mozilla Firefox . . . . . . . . . . . . . . . . . . . . . 15 

1.2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

1.2.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

1.2.3 Installation de polices de caractères optionnelles . . . . . . . 16 

1.2.4 Avertissement . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

1.2.5 Autres navigateurs . . . . . . . . . . . . . . . . . . . . . . . 16 

1.2.6 Retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

1.3 Création de documents XML . . . . . . . . . . . . . . . . . . . . . . 16 

1.3.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

iii

iv 

1.3.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

Autres éditeurs pour le XML . . . . . . . . . . . . . . . . . . 18 

1.3.3 Retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

1.4 Introduction à XML . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

1.4.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

1.4.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

1.4.3 Quelques notions du XML . . . . . . . . . . . . . . . . . . . 19 

1.4.4 La philosophie du XML . . . . . . . . . . . . . . . . . . . . 21 

1.4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

1.4.6 Questions d’auto-évaluation . . . . . . . . . . . . . . . . . . 22 

1.4.7 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

1.5 Principes de XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 

1.5.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 

1.5.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 

1.5.3 Quelques principes et notions importantes du XML . . . . . . 26 

1.5.4 Points importants dans la syntaxe de base . . . . . . . . . . . 28 

1.5.5 Dans l’ordre ou dans le désordre . . . . . . . . . . . . . . . . 29 

1.5.6 Appels d’entités . . . . . . . . . . . . . . . . . . . . . . . . 29 

1.5.7 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . 30 

1.5.8 Les instructions de traitement . . . . . . . . . . . . . . . . . 30 

1.5.9 Jeux de caractères . . . . . . . . . . . . . . . . . . . . . . . 31 

1.5.10 La déclaration XML . . . . . . . . . . . . . . . . . . . . . . 32 

1.5.11 Les espaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

1.5.12 Les fins de ligne . . . . . . . . . . . . . . . . . . . . . . . . 33 

1.5.13 Les hyperliens . . . . . . . . . . . . . . . . . . . . . . . . . 33 

1.5.14 Documents bien formés . . . . . . . . . . . . . . . . . . . . 34 


1.5.16 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 

1.6 Définition de type de document . . . . . . . . . . . . . . . . . . . . . 48 

1.6.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 

1.6.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 

1.6.3 Document XML valable . . . . . . . . . . . . . . . . . . . . 48 

1.6.4 Normes de définition de type de document . . . . . . . . . . . 49 

1.6.5 Documents valables utilisant la norme DTD . . . . . . . . . . 51 

1.6.6 La syntaxe des documents DTD . . . . . . . . . . . . . . . . 52 

1.6.7 Exemple supplémentaire . . . . . . . . . . . . . . . . . . . . 54 

1.6.8 Les attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 

1.6.9 Les entités . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 

1.6.10 DTD interne et externe . . . . . . . . . . . . . . . . . . . . . 57 

1.6.11 Les entités paramètres . . . . . . . . . . . . . . . . . . . . . 58 

1.6.12 Commentaires dans les fichiers DTD . . . . . . . . . . . . . 58 

1.6.13 Une comparaison entre Relax NG et DTD . . . . . . . . . . . 59 

1.6.14 Une approche plus modulaire . . . . . . . . . . . . . . . . . 62 

1.6.15 Définir l’élément-racine . . . . . . . . . . . . . . . . . . . . 64 

1.6.16 Définir le type de contenu en Relax NG . . . . . . . . . . . . 64 

CC BY-NC-SA

v 

1.6.17 Est-ce qu’il existe un outil pour passer d’un format à l’autre 

(DTD, Relax NG, XML Schema) . . . . . . . . . . . . . . . 65 

1.6.18 Est-ce qu’un document DTD est un document XML . . . . . 65 

1.6.19 Pourquoi est-ce qu’il n’est pas suffisant d’utiliser des documents 

bien formés À quoi sert la validation . . . . . . . . . 65 

1.6.20 Est-ce vraiment nécessaire d’avoir des documents valables 

Est-ce que je dois vraiment toujours travailler avec des fichiers 

DTD, XML Schema ou Relax NG . . . . . . . . . . . . . . . 65 

1.6.21 Livres de référence . . . . . . . . . . . . . . . . . . . . . . . 66 


1.6.23 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 

1.7 La validation des documents XML . . . . . . . . . . . . . . . . . . . 91 

1.7.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 

1.7.2 Activité de validation . . . . . . . . . . . . . . . . . . . . . . 92 

Procédure pour valider des documents XML . . . . . . . . . 92 

Vérification de la procédure . . . . . . . . . . . . . . . . . . 96 

1.7.3 Retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 

1.8 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 

1.8.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 

1.8.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 

1.8.3 Les vocabulaires XML . . . . . . . . . . . . . . . . . . . . . 97 

1.8.4 Les identificateurs de ressources uniformes (URI) . . . . . . . 97 

1.8.5 Les espaces de noms . . . . . . . . . . . . . . . . . . . . . . 98 

1.8.6 Les DTD et les espaces de noms . . . . . . . . . . . . . . . . 98 

1.8.7 Déclaration de l’espace de noms . . . . . . . . . . . . . . . . 99 

1.8.8 Les déclarations croisées . . . . . . . . . . . . . . . . . . . . 102 

1.8.9 Le préfixe par défaut . . . . . . . . . . . . . . . . . . . . . . 102 

1.8.10 Rappel des notions formelles . . . . . . . . . . . . . . . . . . 103 

1.8.11 Les espaces de noms et Relax NG . . . . . . . . . . . . . . . 103 

1.8.12 Le préfixe « xml » . . . . . . . . . . . . . . . . . . . . . . . 104 

1.8.13 Rappel : des espaces de noms pour les attributs . . . . . . . 104 

1.8.14 En résumé, qu’est-ce que les espaces de noms . . . . . . . . 105 


1.8.16 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 

1.9 Travail noté 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 

1.9.1 Objectifs et pondération . . . . . . . . . . . . . . . . . . . . 109 

1.9.2 Consignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 

Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 

Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 

Question 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 

Question 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 

Question 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 

Question 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 

Question 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 

Question 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 

Question 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 

CC BY-NC-SA

vi 

Question 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 

Question 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 

Module 2 : XML en tant que syntaxe pour les documents 117 

2.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 

2.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 

2.1.2 Démarche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 

2.2 Introduction au XHTML . . . . . . . . . . . . . . . . . . . . . . . . 118 

2.2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 

2.2.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 

2.2.3 Qu’est-ce que le XHTML . . . . . . . . . . . . . . . . . . . 118 

2.2.4 La structure du document XHTML : head et body . . . . . . . 120 

2.2.5 Les paragraphes en HTML . . . . . . . . . . . . . . . . . . . 120 

2.2.6 Les listes en HTML . . . . . . . . . . . . . . . . . . . . . . 122 

2.2.7 Les tableaux en HTML . . . . . . . . . . . . . . . . . . . . . 123 

2.2.8 Les caractères italiques et gras . . . . . . . . . . . . . . . . . 125 

2.2.9 Les listes de définitions . . . . . . . . . . . . . . . . . . . . . 125 

2.2.10 Les lignes horizontales . . . . . . . . . . . . . . . . . . . . . 126 

2.2.11 Les images . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 

2.2.12 Les hyperliens . . . . . . . . . . . . . . . . . . . . . . . . . 127 

2.2.13 Les abbréviations . . . . . . . . . . . . . . . . . . . . . . . . 127 

2.2.14 Les adresses . . . . . . . . . . . . . . . . . . . . . . . . . . 127 

2.2.15 Les indices et exposants . . . . . . . . . . . . . . . . . . . . 128 

2.2.16 Le code et les exemples . . . . . . . . . . . . . . . . . . . . 128 

2.2.17 Les citations . . . . . . . . . . . . . . . . . . . . . . . . . . 128 

2.2.18 Les révisions . . . . . . . . . . . . . . . . . . . . . . . . . . 128 

2.2.19 La langue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 


2.2.21 Séparation du contenu et de la présentation . . . . . . . . . . 129 

2.2.22 SVG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 

2.2.23 MathML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 

2.2.24 Convertir du HTML mal formé . . . . . . . . . . . . . . . . . 131 

2.2.25 Spécification Relax NG . . . . . . . . . . . . . . . . . . . . . 131 

2.2.26 HTML 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 

2.2.27 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 


2.2.29 Activité d’autoévaluation . . . . . . . . . . . . . . . . . . . . 140 

2.3 XML comme format de documents . . . . . . . . . . . . . . . . . . . 140 

2.3.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 

2.3.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 

2.3.3 Le SGML (Standardized General Markup Language) . . . . . 140 

2.3.4 Le XML comme format de documents . . . . . . . . . . . . . 141 

2.3.5 Le format DocBook . . . . . . . . . . . . . . . . . . . . . . 142 

2.3.6 L’ODF (Open Document Format) . . . . . . . . . . . . . . . 147 


2.3.8 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 

CC BY-NC-SA

vii 

2.4 XML sur le web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

2.4.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

2.4.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 

2.4.3 Le XHTML et le web . . . . . . . . . . . . . . . . . . . . . 155 


2.4.5 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 

2.5 Travail noté 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 


2.5.2 Consignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 

En cas de panne . . . . . . . . . . . . . . . . . . . . . . . . . 166 

Pistes de discussion . . . . . . . . . . . . . . . . . . . . . . . 166 

2.5.3 Critères de correction et de notation . . . . . . . . . . . . . . 166 

2.6 Travail noté 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 

2.6.1 Objectifs, pondération et critères de correction . . . . . . . . 167 

2.6.2 Description du travail . . . . . . . . . . . . . . . . . . . . . . 167 

2.6.3 Consignes . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 

Annexe 1. Document XSLT . . . . . . . . . . . . . . . . . . 170 

Module 3 : Technologies XML 173 

3.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

3.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

3.1.2 Démarche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 

3.2 XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 

3.2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 

3.2.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 

3.2.3 Un regard critique . . . . . . . . . . . . . . . . . . . . . . . 174 

3.2.4 Les machines de Turing et la technologie XML . . . . . . . . 174 

3.2.5 Qu’est-ce que le XSLT . . . . . . . . . . . . . . . . . . . . . 175 

3.2.6 Les langages déclaratifs . . . . . . . . . . . . . . . . . . . . 176 

3.2.7 Les fichiers XSLT . . . . . . . . . . . . . . . . . . . . . . . 176 

3.2.8 « Éléments xsl:template » . . . . . . . . . . . . . . . . . . . 178 

3.2.9 « Éléments xsl:value-of » . . . . . . . . . . . . . . . . . . . . 179 

3.2.10 Arithmétique en XPath . . . . . . . . . . . . . . . . . . . . . 180 

3.2.11 Manipulations des chaînes de caractères en XPath . . . . . . . 181 

3.2.12 Chemins XPath plus sophistiqués . . . . . . . . . . . . . . . 182 

3.2.13 Modularité avec les éléments « xsl:apply-templates » . . . . . 184 

3.2.14 Chemins XPath pour la sélection des attributs . . . . . . . . . 187 

3.2.15 Expression XPath « . » . . . . . . . . . . . . . . . . . . . . . 189 

3.2.16 Spécifier les valeurs d’attributs . . . . . . . . . . . . . . . . . 190 

3.2.17 Expression XPath « .. » . . . . . . . . . . . . . . . . . . . . . 190 

3.2.18 Expression XPath « // » . . . . . . . . . . . . . . . . . . . . 191 

3.2.19 Expression XPath « * » . . . . . . . . . . . . . . . . . . . . 191 

3.2.20 Expression XPath avec « | » . . . . . . . . . . . . . . . . . . 191 

3.2.21 Expression XPath pour le nom d’un élément . . . . . . . . . 192 

3.2.22 Notion de nœuds XSLT . . . . . . . . . . . . . . . . . . . . . 192 

3.2.23 Expressions XPath pour compter et additionner les éléments . 194 

CC BY-NC-SA

viii 

3.2.24 Utilisation de l’attribut « mode » . . . . . . . . . . . . . . . . 195 

3.2.25 Fonction « generate-id » . . . . . . . . . . . . . . . . . . . . 197 

3.2.26 Utilisation des tests . . . . . . . . . . . . . . . . . . . . . . . 198 

3.2.27 Tester le contenu des chaînes de caractères . . . . . . . . . . 199 

3.2.28 Accès aux éléments d’un ensemble d’éléments . . . . . . . . 200 

3.2.29 Utiliser XSLT comme base de données et éléments « for-each » 201 

3.2.30 Obtenir l’aggrégation avec la fonction « generate-id » . . . . . 204 

3.2.31 Un peu plus de performance avec la function XSLT « key » . 208 

3.2.32 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . 209 

3.2.33 Les paramètres . . . . . . . . . . . . . . . . . . . . . . . . . 210 

3.2.34 Générer un commentaire . . . . . . . . . . . . . . . . . . . . 212 

3.2.35 Créer des éléments dynamiquement avec « xsl:element » . . . 212 

3.2.36 Copier des nœuds avec « xsl:copy » et « xsl:copy-of » . . . . 213 

3.2.37 Union, intersection et différence en XSLT . . . . . . . . . . . 214 

3.2.38 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . 215 

3.2.39 Les axes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 

3.2.40 L’étude d’un exemple: docbook.xslt . . . . . . . . . . . . . . 217 

3.2.41 Activité suggérée . . . . . . . . . . . . . . . . . . . . . . . . 220 

3.2.42 Autres moteurs XSLT . . . . . . . . . . . . . . . . . . . . . 220 

3.2.43 Pour voir le résultat de la transformation XSLT . . . . . . . . 220 

3.2.44 SVG et XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . 221 

3.2.45 XPath, XPointer et XLink . . . . . . . . . . . . . . . . . . . 221 

3.2.46 XPath 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 

3.2.47 XLT 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 

3.2.48 XQuery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 

3.2.49 XPath versus XSLT . . . . . . . . . . . . . . . . . . . . . . . 227 

3.2.50 En terminant . . . . . . . . . . . . . . . . . . . . . . . . . . 227 



3.2.53 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 

3.3 CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 

3.3.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 

3.3.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 

3.3.3 Qu’est-ce que les CSS . . . . . . . . . . . . . . . . . . . . . 249 

3.3.4 Point de vue critique . . . . . . . . . . . . . . . . . . . . . . 250 

3.3.5 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . 250 

3.3.6 Contenu en ligne ou en bloc . . . . . . . . . . . . . . . . . 253 

3.3.7 Centrer un élément . . . . . . . . . . . . . . . . . . . . . . . 253 


3.3.9 Sélectionner le premier caractère ou la première ligne . . . . . 254 

3.3.10 Ajouter du contenu avant et après un élément . . . . . . . . . 254 

3.3.11 Qu’est-ce qu’un pseudo-élément . . . . . . . . . . . . . . . 254 

3.3.12 Sélecteurs d’intéraction . . . . . . . . . . . . . . . . . . . . . 255 

3.3.13 Règles par défaut . . . . . . . . . . . . . . . . . . . . . . . . 255 

3.3.14 L’astérisque . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 

3.3.15 Sélection sur la base des attributs . . . . . . . . . . . . . . . 257 

CC BY-NC-SA

ix 


3.3.17 Sélection de la langue . . . . . . . . . . . . . . . . . . . . . 258 

3.3.18 Sélection de plusieurs éléments . . . . . . . . . . . . . . . . 258 

3.3.19 Sélection sur la base de la relation entre les éléments . . . . . 258 

3.3.20 Sélection d’élément par valeur ID . . . . . . . . . . . . . . . 260 

3.3.21 Mais que se passe-t-il en cas de conflit . . . . . . . . . . . . 261 

3.3.22 Le modèle de boîte CSS . . . . . . . . . . . . . . . . . . . . 263 

3.3.23 Quand le contenu excède le contenant . . . . . . . . . . . . . 265 

3.3.24 Encodage des caractères . . . . . . . . . . . . . . . . . . . . 265 

3.3.25 Différentes règles pour différents média . . . . . . . . . . . . 265 

3.3.26 Inclure d’autres fichiers CSS . . . . . . . . . . . . . . . . . . 265 

3.3.27 Indentation de la première ligne d’un paragraphe . . . . . . . 266 

3.3.28 Modifier la casse du texte . . . . . . . . . . . . . . . . . . . 266 

3.3.29 Autres variantes des polices . . . . . . . . . . . . . . . . . . 266 

3.3.30 Ajouter des compteurs . . . . . . . . . . . . . . . . . . . . . 266 

3.3.31 Traitement des retours de chariot . . . . . . . . . . . . . . . . 267 

3.3.32 Des nouveautés en CSS 3 . . . . . . . . . . . . . . . . . . . 267 

3.3.33 Optimisation des fichiers CSS . . . . . . . . . . . . . . . . . 268 

3.3.34 En terminant . . . . . . . . . . . . . . . . . . . . . . . . . . 269 



3.3.37 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 

3.4 Travail noté 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 


3.4.2 Consignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 

3.4.3 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 

3.4.4 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 

3.4.5 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 

3.4.6 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 

3.4.7 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 

Module 4 : Traitement du XML en Java 281 

4.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 

4.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 

4.1.2 Démarche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 

4.2 Modèles de programmation . . . . . . . . . . . . . . . . . . . . . . . 282 

4.2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 

4.2.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 

4.2.3 Traitement du XML comme du texte . . . . . . . . . . . . . . 283 

4.2.4 Traitement événementiel . . . . . . . . . . . . . . . . . . . . 284 

4.2.5 Traitement avec itérateurs . . . . . . . . . . . . . . . . . . . 287 

4.2.6 Traitement avec modèle en arbre . . . . . . . . . . . . . . . . 288 

4.2.7 Transformations . . . . . . . . . . . . . . . . . . . . . . . . 289 

4.2.8 XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 

4.2.9 XML comme extension d’un langage . . . . . . . . . . . . . 290 

4.2.10 Traitement par abstraction . . . . . . . . . . . . . . . . . . . 291 

CC BY-NC-SA

x 

4.2.11 Sérialisation XML . . . . . . . . . . . . . . . . . . . . . . . 291 

4.2.12 Services web . . . . . . . . . . . . . . . . . . . . . . . . . . 293 


4.2.14 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 

4.3 Rappel sur la programmation Java . . . . . . . . . . . . . . . . . . . 299 

4.3.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 

4.3.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 

4.3.3 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 

Notion d’objet . . . . . . . . . . . . . . . . . . . . . . . . . 299 

Notion de classe . . . . . . . . . . . . . . . . . . . . . . . . 300 

Notion de méthode . . . . . . . . . . . . . . . . . . . . . . . 300 

Notion d’interface . . . . . . . . . . . . . . . . . . . . . . . 300 

Notion d’héritage . . . . . . . . . . . . . . . . . . . . . . . . 300 

Notion d’encapsulation . . . . . . . . . . . . . . . . . . . . . 300 

4.3.4 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 

4.3.5 Exemples avancés . . . . . . . . . . . . . . . . . . . . . . . 301 

4.3.6 Lecture de fichiers . . . . . . . . . . . . . . . . . . . . . . . 302 

4.3.7 Astuces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 

4.3.8 Retour sur l’activité . . . . . . . . . . . . . . . . . . . . . . . 302 

4.4 Tutoriel sur DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 

4.4.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 

4.4.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 

4.4.3 Le tutoriel pour se familiariser avec le DOM . . . . . . . . . 303 

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 303 



4.4.6 Un document XML . . . . . . . . . . . . . . . . . . . . . . . 304 

4.4.7 Charger un document XML en Java . . . . . . . . . . . . . . 304 

4.4.8 Accès à l’élément-racine . . . . . . . . . . . . . . . . . . . . 305 

4.4.9 L’interface « Node » . . . . . . . . . . . . . . . . . . . . . . 306 

4.4.10 Création de documents . . . . . . . . . . . . . . . . . . . . . 311 

4.4.11 Modifier un « Document » . . . . . . . . . . . . . . . . . . . 314 


4.4.13 Deux problèmes avec solution . . . . . . . . . . . . . . . . . 317 

Problème 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 

Solution du problème 1 . . . . . . . . . . . . . . . . . . . . . 318 

Problème 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 

Solution du problème 2 . . . . . . . . . . . . . . . . . . . . . 319 

4.4.14 DOM et ECMAScript . . . . . . . . . . . . . . . . . . . . . 321 

4.4.15 Asynchronous JavaScript And XML (AJAX) . . . . . . . . . 322 

4.4.16 DOM et autres langages . . . . . . . . . . . . . . . . . . . . 327 

4.4.17 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 


4.5 DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 

4.5.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 

4.5.2 Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 

CC BY-NC-SA

xi 


4.5.4 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 

4.6 Travail noté 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 


4.6.2 Consignes générales . . . . . . . . . . . . . . . . . . . . . . 330 

4.6.3 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 

4.6.4 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 

4.6.5 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 

4.6.6 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 

4.6.7 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 

Module 5 : Resource Description Framework (RDF) 337 

5.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 

5.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 

5.1.2 Représentation des connaissances et graphes . . . . . . . . . 337 

5.1.3 Démarche . . . . . . . . . . . . . . . . . . . . . . . . . . . 338 

5.1.4 Préparation à l’examen . . . . . . . . . . . . . . . . . . . . 339 

5.1.5 Évaluation du cours . . . . . . . . . . . . . . . . . . . . . . 339 

5.2 Introduction au RDF . . . . . . . . . . . . . . . . . . . . . . . . . . 339 

5.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 



5.2.4 Le RDF en XML . . . . . . . . . . . . . . . . . . . . . . . . 344 

5.2.5 Les classes en RDF . . . . . . . . . . . . . . . . . . . . . . . 348 

5.2.6 Et s’il n’y a pas de symbole « # » dans l’URI . . . . . . . . . 349 

5.2.7 Des objets qui sont eux-mêmes des sujets . . . . . . . . . . . 350 

5.2.8 Les contenants en RDF . . . . . . . . . . . . . . . . . . . . . 353 

5.2.9 RDFa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 

5.2.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 

5.3 Questionnaire d’autoévaluation : Introduction au RDF . . . . . . . . . 355 


5.3.2 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 

5.4 Le RDF par l’exemple . . . . . . . . . . . . . . . . . . . . . . . . . 361 

5.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 

5.4.2 Un exemple : Dublin Core . . . . . . . . . . . . . . . . . . . 361 

5.4.3 Un exemple : Creative Commons . . . . . . . . . . . . . . . 365 

5.4.4 Un exemple : FOAF . . . . . . . . . . . . . . . . . . . . . . 369 

5.4.5 Un exemple : RSS/RDF . . . . . . . . . . . . . . . . . . . . . 371 

5.4.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 

5.5 Questionnaire d’autoévaluation : Le RDF par l’exemple . . . . . . . 374 


5.5.2 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 

5.6 Travail noté 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 


5.6.2 Consignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 

5.6.3 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 

CC BY-NC-SA

xii 

5.6.4 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 

5.6.5 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 

5.6.6 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 

5.6.7 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 

5.6.8 Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 

Avant de réaliser l’exercice... . . . . . . . . . . . . . . . . . 379 

Exercice à réaliser... . . . . . . . . . . . . . . . . . . . . . . 381 

5.6.9 Exercice 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 

Annexe A : Glossaire 383 

Annexe B : Webographie XML 387 

1 Blogues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 

2 Cours en ligne, en français . . . . . . . . . . . . . . . . . . . . . . . 387 

3 Cours en ligne, en anglais . . . . . . . . . . . . . . . . . . . . . . . . 387 

4 Liens généraux, en français . . . . . . . . . . . . . . . . . . . . . . . 387 

5 Articles, en français . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 

6 Articles, en anglais . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 

7 Références tirées du site Wikipedia (anglais) . . . . . . . . . . . . . . 388 

7.1 Spécification XML . . . . . . . . . . . . . . . . . . . . . . . 388 

7.2 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 

7.3 Ressources pour les développeurs . . . . . . . . . . . . . . . 388 

8 Liens vers des livres portant sur le XML, en anglais . . . . . . . . . . 389 

Annexe C : Pense-bête DTD 391 

Annexe D : Pense-bête HTML 393 

Annexe E : Pense-bête XSLT 395 

Bibliographie 399 

CC BY-NC-SA

Guide d’étude 

Introduction 

Bienvenue dans le cours INF 6450 Gestion de l’information avec XML. Mon nom est 

Daniel Lemire et je suis le professeur de ce cours. J’anime un blogue sur le XML à 

l’adresse http://www.daniel-lemire.com/ blogue/category/xml/. 

Avertissement: le site web du cours utilise une technique HTML qui rend l’utilisation 

du bouton « Reculer d’une page » hasardeuse. 

Ce document contient toutes les informations utiles à votre démarche dans le cours. 

Je vous suggère, avant de commencer l’étude du premier module, de prendre connaissance 

des objectifs du cours, de son contenu, de sa problématique, de son organisation 

en modules, des caractéristiques médiatiques de son environnement, ainsi que des propositions 

de répartition de votre temps d’étude pendant les quinze semaines du cours. 

Normalement, vous étudierez les modules de façon séquentielle; des indications plus 

précises sont fournies dans chaque module quant aux liens entre les différentes activités. 

L’installation du navigateur Firefox est obligatoire pour suivre ce cours; c’est d’ailleurs 

la première activité du module 1. 

Objectifs 

Le but de ce cours est de vous donner tous les outils nécessaires pour utiliser le XML 

dans un projet en technologie de l’information, que ce soit un projet de développement 

logiciel, un projet scientifique, ou dans le cadre d’un système d’informations. Il est 

aussi une préparation utile pour des travaux en gestion des connaissances, recherche 

d’informations, bibliothéconomie, e-Learning, génie logiciel, web sémantique, etc. 

Les objectifs du cours sont : 

– Utiliser un « vocabulaire » ou une application XML pour présenter des informations 

en format XML. 

1


– Déterminer si un document XML est bien formé ou valable. 

– Apprécier les coûts de développement de solutions XML au sein d’une organisation. 

– Appliquer la méthodologie orientée objet pour l’utilisation, la fusion et le filtrage 

des fichiers XML. 

– Produire et interpréter des fichiers XML : des fichiers les plus simples aux fichiers 

RDF. 

– Utiliser des transformations XSLT et des instructions CSS. 

– Traduire, au sein de son organisation, sa compréhension du XML dans la gestion des 

informations. 

– Interpréter un fichier RDF comme un tableau sujet/verbe/objet. 

Contenu 

Dans ce cours, nous traiterons des points suivants : 

– Historique, raisons qui ont entraîné la création du XML, comparaison avec HTML 

et SGML 

– Le document XML : syntaxe, éléments, attributs et entités 

– Documents bien formés 

– Documents valables : Document Type Definitions (DTD), XML Schema, Relax NG, 

Schematron et Examplotron 

– Vocabulaires et espaces de noms 

– Le XML comme format de document: XHTML, SVG, MathML, Open Document 

Format et DocBook. 

– Modélisation de l’information en XML 

– XML, XSLT, XPath, XLink, XPointer, XQuery, CSS 

– Utilisation du XML à partir de langages orientés objets (Java, JavaScript, C++) 

– Modèle objet XML (DOM) 

– Asynchronous JavaScript And XML (AJAX) 

– Filtrage, fusion et extraction du XML en Java 

– Métadonnées en XML : Resource Description Framework (RDF), Dublin Core, 

Creative Commons, FOAF, RSS 1.0, web sémantique. 

Le cours ne traite pas en profondeur des technologies propriétaires telles que celles 

d’Oracle ou de Microsoft. Le cours n’en demeure pas moins axée sur la pratique : tous 

les concepts introduits dans le cours sont mis en application. Parce que le cours se veut 

une préparation à l’utilisation du XML dans des projets concrets, les avantages et les 

inconvénients des diverses techniques sont présentés. 

Problématique 

La gestion des connaissances se fait de plus en plus en utilisant la technologie du web, 

qui se tourne elle-même vers les données semi-structurées et la syntaxe XML, en 

CC BY-NC-SA

Problématique 3 

particulier. Le XML (Extensible Markup Language) est la norme dans l’échange des 

données sur le web et au sein des organisations, tout en étant un des piliers du web 

sémantique. Les applications et outils supportant le XML, que ce soit pour l’analyse 

syntaxique, le filtrage ou autres activités, sont maintenant très sophistiqués, nombreux 

et s’appliquent à des domaines variés. Pour s’en convaincre, il suffit de voir la liste des 

acronymes et les sujets auxquels ils correspondent : OWL (ontologies), RDF (description 

des ressources), XSL (transformations et présentation), RuleML (logique), etc. 

Dans une organisation, le XML joue un rôle sur au moins trois plans : 

1. Découplement des informations; 

2. Interopérabilité; 

3. Flexibilité et évolution des schémas de données. 

Découplement des informations 

Dans la gestion des connaissances, le XML joue souvent un rôle dans le découplement 

des informations : métadonnées versus données, présentation versus contenu, implémentation 

versus logique, etc. L’ubiquité du XML et des outils le supportant permet, 

par exemple, de découpler de façon pratique le système d’exploitation et le logiciel 

de traitement de texte utilisé : les fichiers Open Office et les nouveaux fichiers Microsoft 

Office sont en format XML, permettant ainsi, en principe, à n’importe quelle 

plateforme logicielle d’aller chercher le contenu, le texte. Cette interopérabilité n’était 

pas possible avec le format binaire « traditionnel » que Microsoft utilisait dans les 

années 90. Le nouveau format utilisé par Microsoft Word distingue nettement la présentation 

du contenu. De la même manière, le format XHTML permet de laisser le 

contenu textuel semi-structuré dans le fichier lui-même et de placer la présentation 

dans un fichier CSS. D’autre part, tout fichier XHTML peut être facilement traité par 

un analyseur de syntaxe XML générique, peu importe la plateforme avec laquelle il a 

été produit. Au contraire, le HTML « traditionnel » exige des analyseurs de syntaxe 

spécifiques au HTML et de conception très robuste. 

XML et interopérabilité 

Pour une organisation, le fait de stocker, ou du moins de pouvoir transformer, les informations 

et les connaissances en XML rend beaucoup plus facile qu’auparavant le 

partage de ces mêmes informations et connaissances. En principe, n’importe qui peut 

traiter les fichiers XML provenant de n’importe quelle organisation en utilisant un logiciel 

générique. Dans une certaine mesure, on se met à l’abri du blocage de la part 

d’un fournisseur (vendor locking), ce qui a tant nui à plusieurs organisations dans le 

passé. Par exemple, c’était le cas d’une entreprise qui utilisait, pour une fonction stratégique, 

un logiciel conçu par une société qui devait fermer ou qui refusait de fournir 

une fonction particulière pourtant nécessaire. Si les informations sont en format XML, 

il est possible, du moins en théorie, pour une organisation d’extraire avec précision 

CC BY-NC-SA


l’information et de la traiter; il lui suffit d’utiliser n’importe quel analyseur de syntaxe 

XML et de comprendre l’application XML utilisée. 

Pensons à une entreprise distribuée qui, pour collaborer, doit non seulement s’entendre 

sur une ontologie commune entre ses différentes constituantes, mais aussi définir un 

protocole d’échange des informations et connaissances. Comme le XML s’est imposé 

en tant que norme, le problème est simplifié : il suffit maintenant de « seulement » 

s’entendre sur un vocabulaire. Le XML fournit non seulement la syntaxe, mais aussi 

les outils nécessaires pour vérifier qui respecte ou ne respecte pas la syntaxe. Les outils 

pour modifier, traiter, fusionner le XML ne sont plus spécifiques aux besoins d’une 

entreprise ou d’un type d’entreprise : tous partagent les mêmes outils de base, car tous 

utilisent la même syntaxe. Les problèmes d’intégration sont donc plus faciles à résoudre 

et on passe moins de temps à faire de la rétro-ingénierie (reverse-engineering). Il faut 

évidemment toujours bien documenter et comprendre les vocabulaires, mais un lot de 

problèmes purement techniques sont balayés. 

Pensons également aux projets récents portant sur les objets d’apprentissage sur lesquels 

travaille la Télé-université. La plupart de ces projets sont constitués en réseaux : 

on désire échanger des objets d’apprentissage entre des individus qui ne se rencontrent 

jamais. Ainsi, en utilisant, par exemple, l’application XML IEEE LOM pour décrire 

aux clients potentiels nos objets, nous savons que le récipiendaire, peu importe sa plateforme 

logicielle, pourra au minimum traiter la syntaxe. Le XML n’est donc pas un 

progrès ou une nouveauté technologique : la théorie de la syntaxe des fichiers textes est 

un sujet bien développé. Le XML s’impose davantage comme progrès social : le web 

a amené les gens à s’entendre une fois pour toute sur une syntaxe suffisamment simple 

et universelle pour les documents semi-structurés. 

Le cours INF 6450 Gestion de l’information avec XML ne porte donc pas uniquement 

sur la technologie elle-même; il envisage plutôt le XML comme une norme, mais aussi 

comme un ensemble de normes, incluant RDF, qui ont toutes en commun d’avoir un 

lien fort avec le web et la gestion de l’information et des connaissances. 

Flexibilité et évolution des schémas de données 

Un autre rôle du XML dans l’organisation : se substituer aux modèles relationnels 

dans lesquels on impose des champs de données fixes. Par exemple, on décrit chaque 

étudiant par un numéro de matricule, un nom et une date de naissance; on peut aussi 

associer l’étudiant à une liste de cours suivis. Bien que le modèle relationnel puisse 

sembler très flexible, il n’est pas toujours idéal : le web n’est pas une base de données 

relationnelles et, en fait, ce n’est pas du tout une base de données. S’il fallait convertir 

les pages web HTML en un schéma de base de données relationnelles, on constaterait 

rapidement qu’il s’agit d’un travail fastidieux, voire impossible. 

D’un autre côté, les pages web, les documents Microsoft Word et d’autres formes de 

données non structurées possèdent aussi leurs inconvénients. Supposons que j’accède 

au bottin de la Téluq par le web. En principe, je peux écrire un programme qui va 

automatiquement chercher le numéro de téléphone de « Richard Hotte ». En pratique 

CC BY-NC-SA

Les modules du cours 5 

cependant, comme le HTML est avant tout un format de présentation de l’information, 

cette approche est fragile et peu pratique : les machines ont tout simplement beaucoup 

de mal à extraire de l’information précise à partir de documents non structurés, contrairement 

aux êtres humains qui peuvent très bien reconnaître que telle page web présente 

bel et bien le numéro de téléphone de « Richard Hotte ». 

Ainsi, le XML se situe un peu entre les bases de données et les formats sans sémantique 

: on parle d’information semi-structurée. On garde une grande partie de la flexibilité 

qui a permis au web de devenir l’outil unique de gestion de l’information que l’on 

connaît. En même temps, on permet aux systèmes informatiques d’interagir avec toute 

cette information de façon automatique. De plus, avec le XML, il n’est pas du tout problématique 

de concevoir des schémas d’information ou de les réutiliser. En somme, le 

XML représente un compromis à la fois sémantique et flexible. 

Les modules du cours 

Le cours comporte 5 modules. Le premier module introduit au XML proprement dit : 

sa syntaxe et ses capacités de modélisation. Le module 2 porte sur le XML en tant que 

format pour les documents; on y présente la notion de séparation du contenu et de la 

présentation. Les modules 3, 4 et 5 portent respectivement sur l’ensemble de ce que l’on 

nomme parfois les « technologies XML » incluant XSLT, CSS, etc., sur le traitement 

du XML en utilisant un langage de programmation comme Java et, finalement, sur le 

RDF en tant que langage pour la description des ressources. 

Pour chaque module, nous avons rédigé des textes d’appoint et préparé des questionnaires 

d’autoévaluation qui vous permettront de vérifier votre maîtrise du contenu, au 

fur et à mesure de votre apprentissage. En outre, pour nous permettre de vous évaluer, 

vous réaliserez un travail noté par module. 

Il est préférable de procéder à l’étude des modules de façon séquentielle : en effet, 

il faut d’abord savoir interpréter la syntaxe XML avant de pouvoir aborder le XML 

comme format pour les documents. En outre, il faut une connaissance du XML comme 

format de document pour comprendre l’utilité des « technologies XML » et faire du 

traitement en Java. Finalement, le RDF exige une maîtrise suffisante de l’ensemble du 

XML, parce que la syntaxe peut sembler rébarbative à quelqu’un peu expérimenté. Il 

est cependant possible d’aborder les modules 3 et 4 de front. 

En résumé, le cours comporte les cinq modules suivants : 

– Module 1 : Introduction à XML (extensibilité, DTD, Relax NG, XML Schema, espaces 

de noms) 

– Module 2 : XML en tant que syntaxe pour les documents (XHTML, SVG, MathML, 

DocBook, ODF) 

– Module 3 : Technologies XML (XSLT, CSS, XPath, XQuery, XLink) 

– Module 4 : Traitement du XML en Java (DOM, SAX, Itérateurs, Sérialisation, 

AJAX, Services web) 

CC BY-NC-SA


– Module 5 : Resource Description Framework (RDF) (Dublin Core, Creative Commons, 

FOAF, RSS 1.0, Atom) 

Caractéristiques médiatiques 

L’environnement du cours est un site web réalisé entièrement en XML. Les figures 

sont en SVG (un format XML couvert dans le cours). Vous pouvez faire vos lectures 

(textes, consignes, etc.) sur le site, mais aussi en utilisant un document imprimé, (Manuel 

INF 6450) généré à partir du site web par une transformation XSLT (sujet couvert 

dans le cadre du cours). Le cours contient de nombreux exemples de code en XML et 

Java : vous devriez être capable, à la fin du cours, de lire sans mal du XML en ligne, 

sans coloration syntaxique. Tous les modules comprennent des activités d’autoévaluation 

sous la forme de questionnaires (rédigés eux-même en XML) visant à vérifier 

la compréhension de vos lectures; vous répondrez à ces questionnaires sur le site, en 

ligne, car leur efficacité est optimisée par les possibilités du web. Un va-et-vient entre 

lectures et questionnaires d’autoévaluation s’imposera, mais à votre rythme. 

En outre, sur le site web, se trouvent la documentation touchant l’installation et l’utilisation 

du logiciel Firefox nécessaire au cours, diverses activités de création et de validation 

de documents XML, les consignes pour les travaux notés, les pense-bêtes qui, 

comme leur nom l’indique, vous seront utiles à différents moments. Vous y avez accès 

par des hyperliens dans la colonne de gauche de la page-écran, et ce pour chaque 

module. 

Les étudiants qui désirent un livre de référence pour ce cours peuvent acheter « XML en 

concentré : Manuel de référence » d’Elliotte Rusty Harold, W-Scott Means, Philippe 

Ensarguet (traducteur), Frédéric Laurent (traducteur) chez O’Reilly paru le 21 avril 

2005 (ISBN : 2841773531). En outre, un des auteurs de ce livre de référence, Elliotte 

Rusty Harold a une page d’actualité sur le XML: Cafe con Leche XML News and 

Resources. 

Par ailleurs, nous avons préparé une feuille de route qui donne un aperçu de la démarche, 

un glossaire définissant quelques termes importants du cours et une webographie 

contenant plusieurs liens en français et en anglais. Ils sont accessibles en tout 

temps à partir des modules, par des boutons placés dans la partie supérieure de la pageécran. 

Encadrement 

L’encadrement, assuré par une personne tutrice que vous assigne l’Université, se fait 

par courriel. Ainsi, toutes vos interrogations sur le cours ou sur l’environnement d’apprentissage 

doivent lui être adressées par courriel; celle-ci y répondra dans les plus 

CC BY-NC-SA

L’évaluation 7 

brefs délais. Par ailleurs, nous vous demandons d’inscrire « [INF6450] » dans l’objet 

de tous vos messages. En ce qui concerne les travaux notés que vous transmettrez 

également par courriel à votre personne tutrice pour qu’elle les corrige, vous 

devrez en plus indiquer, dans l’objet du message, le numéro du travail, par exemple 

« [INF6450][TRAVAIL5] »; dans le message de transmission, vous indiquerez également 

votre nom, votre numéro d’étudiant (8 chiffres), la date de remise de votre travail 

et le nom de votre personne tutrice. Des consignes précises sont fournies dans chaque 

travail noté. 

L’évaluation 

Pour évaluer vos apprentissages dans ce cours, nous avons préparé 6 travaux notés et 

un examen en salle. Le tableau qui suit les présente sommairement. 

Activités notées Modules Pondération 

Travail noté 1 (questionnaire) 

Module 1 10 % 

Travail noté 2 (discussion Modules 2-5 5 % 

et compte rendu) 

Travail noté 3 (rédaction) Module 2 10 % 

Travail noté 4 (programmation) 

Module 3 10 % 


Module 4 15 % 


Module 5 10 % 

Examen en salle Modules 1-5 40 % 

Total 100 % 

Les travaux notés 

Les travaux notés 1, 3, 4, 5 et 6 sont associés à un module et vérifient l’atteinte des 

objectifs de ce module. Le travail noté 1 prend la forme d’un questionnaire, le travail 

noté 3 consiste à rédiger un document en XML; les travaux notés 4, 5 et 6 comportent 

des exercices qui exigent de la programmation. Je vous recommande de réaliser ces 

travaux notés après avoir effectué les lectures et les activités d’autoévaluation du module 

en question. Il n’est pas nécessaire de faire les travaux dans l’ordre qu’ils apparaissent 

dans le cours; en effet, le travail noté 3 peut être fait après les autres travaux, 

par exemple. Cependant, le travail noté 1 doit être fait avant les autres et le travail 

noté 6, après les travaux notés 4 et 5. 

Quant au travail noté 2, la discussion dans le forum du cours, il peut commencer dès 

le début du module 2 et vous avez toute la durée du cours pour le réaliser. Avant de 

commencer cette activité, nous vous suggérons fortement d’avoir terminé l’étude du 

CC BY-NC-SA


module 1, car il faut bien comprendre les définitions et concepts de base du XML. 

Notez que l’évaluation du travail 2 porte sur le compte rendu que vous rédigerez à la 

suite de votre participation dans le forum. Tous les travaux doivent être transmis à la 

personne tutrice par courriel. 

Examen en salle 

L’examen en salle compte pour 40 % de la note du cours. Il s’agit d’un examen de 

3 heures comportant 5 questions, lesquels portent sur le contenu couvert par les travaux 

1, 3, 4, 5 et 6. Un examen factice est disponible dans le dernier module pour vous 

permettre de vérifier si vous êtes prêt. La correction de l’examen est rigoureuse : vous 

devez décrire le comportement exact des programmes et pouvoir répondre aux questions 

de façon aussi précise que durant les travaux. Il est important d’avoir lu tous les 

textes et d’avoir fait toutes les activités d’autoévaluation du cours pour réussir l’examen. 

Aucune documentation n’est permise durant l’examen. 

Vers la douzième semaine du cours, l’Université vous informera de la date, de l’heure 

et de l’endroit de passation de l’examen. 

Gestion du temps et pondération 

Dans le tableau qui suit, nous indiquons le temps à prévoir pour chaque activité, ainsi 

que la pondération associée à chacune. Le temps consacré à la lecture inclut la lecture 

des textes conçus pour le cours. L’ordre dans lequel les activités sont présentées est 

l’ordre suggéré. 

Activités Temps suggéré Pondération 

Introduction au cours 2 heures Aucune 

Lectures et questionnaires 

15 heures Aucune 

du module 1 

(incluant l’installation 

logicielle) 

Travail noté 1 (questionnaire) 

5 heures 10 % 



du module 2 

Travail noté 2 (discussion 5 heures 5 % 

dans le forum et compte 

rendu) 

Travail noté 3 (rédaction) 15 heures 10 % 



du module 3 

(incluant la programmation 

XSLT et CSS) 

CC BY-NC-SA

Gestion du temps et pondération 9 

Activités Temps suggéré Pondération 


20 heures 10 % 



du module 4 

(incluant la programmation 

Java) 





du module 5 



Examen 3 heures 40 % 

Total 135 heures 100 % 

Un deuxième tableau répartit les activités selon les semaines, en comptant une moyenne 

de 9 heures de travail par semaine, pendant 15 semaines. La participation au forum 

s’étale sur plusieurs semaines (environ les deux tiers du cours). 

Semaine 

Activités 

1 Présentation du cours, lectures et questionnaires 

(module 1) 

2 Lectures et questionnaires (module 1) 

3 Travail noté 1, lectures et questionnaires 

(module 2) 

4 Lectures et questionnaires (module 2), 

travail noté 2: forum 

5 Travail noté 3 

6 Forum, travail noté 3, lectures et questionnaires 

(module 3) 

7 Forum, lectures et questionnaires (module 

3) 

8 Forum, travail noté 4 



(module 4) 


4), travail noté 5 



(module 5) 


5), travail noté 6 


CC BY-NC-SA


Semaine 

Activités 

Examen en salle 

À partir du tableau précédent, nous vous proposons un tableau semaine/module. Un 

« X » indique que des activités du module en question sont prévues pour une semaine 

donnée. L’astérisque signifie que vous devriez terminer le travail noté prévu pour ce 

module durant la semaine marquée. 

Semaine Module 1 Module 2 Module 3 Module 4 Module 5 

1 X 

2 X 

3 X* X 

4 X 

5 X 

6 X* X 

7 X 

8 X 

9 X 

10 X* X 

11 X 

12 X 

13 X* X 

14 X 

15 * Forum X* 

Version PDF du cours 

Le cours est non seulement disponible en XML sur le web, mais aussi en format PDF. 

En effet, un des avantages de la séparation du contenu et de sa présentation, tel qu’on 

l’enseigne dans le cours, c’est qu’on peut ensuite présenter l’information selon plusieurs 

formats. Dans ce cours, nous avons utilisé XSLT pour transformer le XML en 

PDF. La version papier que vous avez reçue, intitulée Manuel INF 6450 (version pdf), 

est une version pdf écourtée du cours; elle comprend le guide d’étude qui présente le 

cours, le contenu de chaque module et le travail noté qui lui est associé, ainsi que le 

glossaire, la webographie et les trois pense-bêtes, mais pas les questionnaires d’autoévaluation; 

ce manuel compte plus de 200 pages. 

Vous pouvez y accéder par le lien qui suit : 

– Manuel INF 6450 (1,2 Mo). 

Vous pouvez aussi accéder au manuel complet du cours par ce lien : 

– Manuel INF 6450 complet (1,6 Mo). 

CC BY-NC-SA

Remerciements 11 

Remerciements 

Le cours INF 6450 Gestion de l’information avec XML a été conçu par le professeur 

Daniel Lemire avec la collaboration de Kamel Aouiche, assistant de recherche, de Lucie 

Moulet, assistante de recherche, et du concepteur associé Jean-François Savard. 

Le professeur Lemire les remercie vivement; il remercie également les professeurs 

Koné Mamadou Tadiou (Université Laval), Richard Hotte (UQAM) et Marc Couture 

(UQAM), ainsi que le spécialiste en sciences de l’éducation Robert Ippersiel, qui ont 

effectué une lecture critique de la documentation du cours. Un des étudiants du cours, 

monsieur Dosseh Abiassi, a signalé plusieurs pages de coquilles. 

En outre, le professeur remercie chaleureusement Renée Dumas, spécialiste en communication 

écrite, pour son apport à la qualité linguistique du cours, pour son sens 

pédagogique de la communication et pour sa complicité dans cette aventure. Il remercie 

également l’équipe de production multimédia, dirigée par Jean-Charles Dormeux, 

pour leur sollicitude et leur professionnalisme. 

CC BY-NC-SA

Module 1 : Introduction à XML 

1.1 Aperçu 

1.1.1 Objectifs 

À la fin de ce module, vous devriez avoir une bonne idée de ce qu’est le XML et pouvoir 

facilement lire et écrire du XML simple. Les objectifs spécifiques du module sont : 

– Utiliser un vocabulaire ou une application XML pour présenter des informations en 

format XML; 

– Déterminer si un document XML est bien formé ou valable; 

– Interpréter des fichiers XML utilisant des espaces de noms. 

Avant d’entreprendre votre démarche dans ce module, nous vous invitons à lire le texte 

qui suit pour avoir un aperçu de ce qu’est le XML. 

1.1.2 Qu’est-ce que le XML 

Le XML ou Extensible Markup Language est une syntaxe générique utilisée pour formater 

des données avec des balises simples et lisibles. Par exemple, pour décrire un 

étudiant, une syntaxe XML possible serait : 

 

Tremblay 

Jean 

849490234 

 

Par la suite, si nous désirions décrire l’ensemble des étudiants inscrits à un cours, nous 

pourrions utiliser la syntaxe suivante : 

 

Introduction au traitement de texte 

13


Téluq 

 

 

Tremblay 

Jean 

849490234 

 

 

Hotte 

Richard 

8443444 

 

 

 

Dans ces exemples, observez la présence de texte entre les signes < et > : il s’agit de 

balises. Une balise marque le début ou la fin d’un élément. La balise marque 

le début de l’élément « cours », alors que la balise en marque la fin. Notez 

qu’un élément peut contenir d’autres éléments, et ainsi de suite. 

Cette nouvelle syntaxe a émergé dans les années 90, avec le développement du web. 

Depuis, le XML est devenu très courant dans l’industrie informatique et fait partie des 

notions de base que les informaticiens doivent maîtriser, au même titre que les bases 

de données ou la programmation orientée objet. Elle est caractérisée par la simplicité 

d’abord : le HTML et le XML ont un parent commun, le SGML qui était complexe 

et difficile à maîtriser; on a donc voulu « réparer » le SGML, en proposant des solutions 

plus simples. Entre autres choses, le web a permis d’observer que les technologies 

simples pouvaient être très puissantes; c’est ce qui en a fait toute la force : une technologie 

accessible, ouverte et avec un minimum de complexité. 

D’ailleurs, l’inventeur du web, Tim Berners-Lee a rapidement adopté le XML et en 

propose, depuis, une nouvelle vision qui repose entièrement sur le XML : le web sémantique. 

La prémisse étant que, si l’on sépare le contenu de la présentation, le web 

n’en sera que plus riche. En effet, on observe que les formats qui confondent la présentation 

et le contenu, tels que Microsoft Word ou le HTML, limitent la capacité de nos 

logiciels. Par exemple, il peut être difficile pour un logiciel de trouver automatiquement 

la deuxième section d’un texte placé sur le web et de la reformater automatiquement, 

pour qu’on puisse l’inclure dans un rapport annuel. 

1.1.3 Démarche 

Vous devez étudier et maîtriser le contenu de ce module avant de passer aux autres, car 

il est de base : il définit ce qu’est le XML et vous permet d’apprendre sa terminologie 

propre. Selon les sections de ce module, lisez les textes proposés, faites les activités 

suggérées, répondez aux questionnaires d’autoévaluation. Lorsque vous maîtrisez le 

CC BY-NC-SA

Installation de Mozilla Firefox 15 

contenu du module, réalisez la première activité d’application, le travail noté 1, avant 

de passer au module suivant. 

Nous vous suggérons d’étudier le module dans l’ordre suivant : 

– Installation de Mozilla Firefox 

– Création de documents XML, avec un éditeur de texte 

– Introduction à XML 

– Principes de XML 

– Définition de type de document (DTD), Relax NG et XML Schema 

– Validation des documents XML 

– Espaces de noms 

Le pense-bête présente quelques symboles importants sur les DTD et leur signification; 

dans la version imprimée du cours, il se trouve en annexe. 

1.2 Installation de Mozilla Firefox 

1.2.1 Objectif 

Installer le logiciel Firefox; l’utiliser pour naviguer dans le web ou ouvrir des documents 

sur votre ordinateur. 

1.2.2 Activité 

Si le système d’exploitation de votre ordinateur est Windows, vous utilisez sans doute 

Internet Explorer (IE), le navigateur internet fourni d’office avec ce système. Malheureusement, 

ce navigateur ne supporte pas pleinement le XML et XHTML et, pour ce 

cours, étant donné qu’une partie du contenu est en XML et XHTML, il est nécessaire 

d’utiliser un navigateur qui le supporte parfaitement. Nous vous demandons de télécharger 

un autre navigateur, soit Mozilla Firefox, dont le téléchargement est gratuit. 

Pour la version française de Mozilla Firefox, rendez-vous à l’adresse http://frenchmozilla.sourceforge.net/firefox/; 

lisez les informations, sélectionnez le fichier correspondant 

à votre système d’exploitation et téléchargez-le; lancez ensuite la procédure d’installation 

et suivez bien les directives données. Sous Windows, il est possible que vous 

deviez faire redémarrer votre ordinateur après l’installation. Il est nécessaire d’avoir 

Firefox 2.0 ou mieux pour suivre ce cours: vous pouvez vérifier la version que vous 

avez en tapant « about: » dans la boîte de saisie des URL. 

Quand l’installation sera terminée, vérifiez que vous pouvez utiliser Firefox pour naviguer 

dans le web avant de poursuivre le cours. 

CC BY-NC-SA


1.2.3 Installation de polices de caractères optionnelles 

Il se peut que votre navigateur vous avertisse de l’absence de certaines polices optionnelles 

la première fois que vous chargez une page contenant du MathML. Vous pouvez 

ignorer ces avertissements. Si vous le désirez, afin d’éviter ces avertissements, vous 

pouvez installer des polices de caractères supplémentaires qui sont sur le site du projet 

MathML de la fondation Mozilla. Ce n’est pas nécessaire dans le cadre de ce cours. 

1.2.4 Avertissement 

Firefox est constamment mis à jour par son équipe de développement. Il est possible 

que vous constatiez parfois des différences entre ce qui est annoncé dans le cours et le 

comportement de votre version de Firefox. 

1.2.5 Autres navigateurs 

Outre Firefox, les navigateurs Opera et Camino sont aussi compatibles avec les normes 

XML utilisées dans ce cours. Cependant, pour les fins des activités notées utilisant le 

navigateur et certaines fonctions du site web, il est nécessaire d’utiliser Firefox. 

1.2.6 Retour 

Avez-vous pu installer Firefox et naviguer dans le web Si oui, passez aux prochaines 

activités, sinon contactez votre personne tutrice ou cherchez encore un peu. 

1.3 Création de documents XML 


Créer des documents XML et les ouvrir avec le navigateur Firefox. 


Il est facile de créer des documents XML sous Windows; il faut d’abord ouvrir un 

éditeur de texte. Tout éditeur de texte ferait l’affaire, mais avec Windows, Microsoft 

fournit par défaut Bloc-notes (NotePad). Pour ouvrir le Bloc-notes, il suffit d’aller dans 

le menu « Démarrer », sous « Accessoires », et de cliquer sur l’icône du Bloc-notes. Si 

vous utilisez un autre système d’exploitation que Windows, une petite recherche vous 

permettra de trouver rapidement un éditeur de texte déjà installé sur votre machine. 

Vous n’avez plus qu’à taper du code XML. Comme exercice, tapez le texte suivant : 

CC BY-NC-SA

Création de documents XML 17 

 

Ceci est mon premier document XML. 

 

Enregistrez-le ensuite sous le nom « premier.xml ». Malheureusement, le Bloc-notes 

a la fâcheuse habitude de toujours ajouter l’extension « .txt » à la fin des noms de 

fichiers. Donc, à chaque enregistrement, vous devrez sélectionner « Tous » dans la liste 

déroulante de « Type » de fichier, comme le montre la figure qui suit. 

Bloc-note 

opte par défaut pour le jeu de caractères (ou codage) ANSI ce qui, pour les fins de 

ce cours, correspond au jeu de caractères ISO-8859-1. Sous Windows XP ou mieux, on 

peut aussi sélectionner le jeu de caractères UTF-8. 

Ouvrez maintenant le fichier « premier.xml » dans Firefox, un navigateur qui sait reconnaître 

le XML; vous verrez alors apparaître votre document XML tel que vous l’avez 

tapé. Si vous avez fait une faute de syntaxe XML, Firefox vous l’indiquera. 

Le XML ressemble beaucoup au code HTML avec lequel sont créées les pages web. 

Nous reviendrons plus tard sur le HTML, après avoir étudié plus à fond le XML. Le 

module 2 comporte une activité d’introduction au HTML. Pour l’instant, retenez seulement 

qu’il est possible d’écrire le HTML comme du XML bien formé. L’exemple qui 

suit est un document HTML qui est aussi du XML bien formé. 

 

 

Bonjour 

 

 

CC BY-NC-SA


Comme exercice facultatif, recopiez le texte précédent commençant par et se 

terminant par dans un fichier, en utilisant un éditeur de texte comme le Blocnotes, 

que l’on trouve dans les accessoires de Windows. Enregistrez le fichier sous le 

nom « test.html »; n’oubliez pas de sélectionner « Tous » dans la liste déroulante de 

« Type » de fichier, dans la boîte de dialogue d’enregistrement. Ensuite, ouvrez votre 

fichier avec le navigateur Firefox; vous devriez voir le texte « Bonjour » s’afficher. 

Ces quelques exemples montrent comment il est simple d’utiliser et de créer des fichiers 

XML. Le XML permet toutefois de faire beaucoup plus, comme d’échanger des 

messages entre des applications ou de décrire à un ordinateur le contenu d’un document. 

De la même façon, en utilisant le Bloc-notes, on peut créer des documents DTD (chapitre 

3 du module 1). Nous verrons que les documents DTD sont aussi des fichiers au 

format texte servant à spécifier, dans une certaine mesure, ce qui est permis et ce qui 

ne l’est pas dans un document XML. 

Autres éditeurs pour le XML 

Un produit commercial très recherché pour l’édition du XML est XMLSpy, en anglais 

seulement. C’est probablement l’éditeur XML le plus puissant sur le marché; il en 

existe une version d’essai gratuite. 

Un autre excellent éditeur pour le XML, gratuit et en anglais seulement, est jEdit. 

Comme cet éditeur est un programme Java, il faut installer une machine virtuelle Java 

au préalable, tel le SDK J2SE. En outre, on peut ajouter à jEdit le plugiciel XML 

qui permet de naviguer dans les documents XML et d’en assurer la validité. Le plugiciel 

XSLT permet aussi de tester des documents XSLT et des expressions XPath 

(module 3 du cours). 

Finalement, pour Windows seulement, Cooktop est un éditeur XML gratuit créé par 

Victor Pavlov. Il permet d’éditer des fichiers XML, DTD, et XSLT, en plus de manipuler 

des expressions XPath. 

Sous MacOS, l’éditeur gratuit Smultron est recommandé. 

1.3.3 Retour 

Avez-vous pu créer un document XML avec l’extension XML Est-ce qu’il s’est ouvert 

dans Firefox sans erreur Si oui, passez aux autres activités, sinon contactez votre 

personne tutrice ou cherchez encore un peu. 

CC BY-NC-SA

Introduction à XML 19 

FIG. .1 – Tim Bray en mai 2007 (photographie par Lou Springer). 

1.4 Introduction à XML 


Connaître les notions de base du XML. 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation. Ce texte place 

la technologie XML dans son contexte. 

1.4.3 Quelques notions du XML 

Le XML est un « métalangage » permettant d’échanger de l’information, principalement 

sur le web. Il a été conçu par Tim Bray, Jon Bosak et de nombreux autres collaborateurs, 

entre 1996 et 1999. On dit que c’est un « métalangage » parce qu’il est une 

façon pratique de créer de nouveaux langages pour échanger des informations, mais 

qu’il ne constitue pas un langage en soi. Le XML n’essaie pas, par lui-même, de résoudre 

tous les problèmes : il fournit par contre les outils nécessaires pour que, dans 

tous les domaines, des individus puissent résoudre leurs problèmes. Ainsi, on dit que 

le XML est « extensible » (peut être étendu) et que c’est un métalangage : les deux 

affirmations vont dans le même sens et notent la capacité du XML à s’adapter à des 

besoins différents. 

I looked at it and I saw that the markup said what the information is, 

not what it looks like. Why isn’t everything this way I still basically am 

asking that question. (Tim Bray) 

Un document XML est essentiellement du texte contenant des balises. Une balise est 

un segment de texte commençant par < et se terminant par >, comme . Voici 

un exemple simple de document XML : 

CC BY-NC-SA


 

Jean 

42 

 

Le XML est très présent sur le web et les documents XML peuvent être affichés par 

certains navigateurs récents, comme Internet Explorer et Firefox. On échange aussi le 

XML entre des logiciels et des serveurs sur le web, et le XML est de plus en plus utilisé 

en bureautique, comme format pour les traitements de texte par exemple. Comme un 

document XML est avant tout du texte, il n’est pas avantageux d’utiliser le XML pour 

stocker des informations de type multimédia (vidéo, musique); le champ d’application 

du XML demeure toutefois très vaste. 

Le XML définit une grammaire stricte et relativement simple de manière que les outils 

XML génériques puissent traiter tous les documents XML, peu importe leur domaine 

d’application. On dit d’un document qui respecte cette grammaire qu’il est bien formé. 

Ainsi, il n’est pas nécessaire d’utiliser des outils coûteux et propriétaires pour faire du 

XML. 

L’application la plus commune du XML correspond au scénario suivant. Un groupe de 

personnes travaillant dans un domaine particulier, disons l’industrie de la construction, 

ont besoin d’échanger des informations, par exemple le prix et la description des matériaux. 

Elles doivent s’entendre sur un format informatique commun de manière que 

tous les logiciels, écrits ou utilisés par les différents participants, puissent communiquer 

entre eux, sans problème. L’information pourra ainsi être transmise sans intervention 

humaine. 

Concrètement, on utilise le XML dans le contexte d’une application XML. Une application 

XML est un jeu de balises et son utilisation dans un domaine particulier, par 

exemple la musique ou la cuisine. On peut définir un jeu de balises et, dans une certaine 

mesure, son utilisation en se servant d’un document DTD, Relax NG ou XML 

Schema (sujets que nous étudierons plus tard dans le cours). Dans un sens, une application 

XML forme un langage. On dit d’un document XML qui respecte les normes 

d’une application XML donnée qu’il est valable : un document valable est bien formé. 

En théorie, on pourrait penser que l’importance du XML est mineure. En effet, n’est-il 

pas facile de s’entendre sur des formats communs L’expérience montre que ce n’est 

pas si facile. D’abord, définir avec rigueur un format de données est complexe. D’autre 

part, le développement de logiciels particuliers à chaque format est coûteux : avec un 

métalangage comme XML, on peut réutiliser souvent les mêmes librairies logicielles. 

Finalement, l’individu qui acquiert une expérience avec XML dans le contexte de l’industrie 

de la construction pourra facilement réutiliser cette expertise dans le domaine 

de la mode, par exemple. Il est plus facile de trouver des experts en XML que des 

experts dans un format de données, format particulier à un domaine pointu. 

Le XML n’est pas un langage de programmation bien qu’on puisse l’utiliser avec des 

langages comme Java (module 4). On se sert par contre de plus en plus du XML pour 

CC BY-NC-SA


les fichiers de configuration des logiciels. Par exemple, il est probable que, si vous utilisez 

un serveur web dans votre entreprise, ce serveur ait des fichiers de configuration 

en XML. Un document XML ne fait rien : ce n’est qu’une source passive d’informations, 

comme n’importe quel document, comme des pages web. 

1.4.4 La philosophie du XML 

Le XML met à profit un principe essentiel à l’architecture du web : be conservative 

in what you do, be liberal in what you accept from others (soyez strict dans ce que 

vous produisez, mais généreux dans ce que vous acceptez). En d’autres mots, le XML 

fonctionne parce que les gens tentent le plus possible de produire du XML de qualité 

(bien formé et valable), mais ils acceptent que les autres fassent des entorses aux règles. 

C’est, en partie, ce qu’on entend lorsqu’on dit que le XML est « extensible ». Cette 

règle est parfois appelée la loi de Postel parce qu’elle fut rédigée par Jon Postel dans la 

spécification RFC 793. 

Par exemple, supposons que vous écriviez un logiciel qui s’attend à recevoir des commandes 

ayant la forme suivante. 

 

papier 

2 

 

Supposons maintenant que le logiciel qui émet les commandes est mis à jour et qu’il 

vous transmet dorénavant les commandes sous le format suivant. 

 

papier 

2 

oui 

 

Selon les principes du XML, votre logiciel doit continuer à fonctionner, il doit ignorer 

le nouvel élément qu’il ne connaît pas. En d’autres mots, votre logiciel doit être 

généreux et ne pas exiger une conformité parfaite. Tant qu’il dispose des informations 

dont il a besoin, votre logiciel doit continuer à fonctionner. C’est ce principe fondateur 

qui permet à des millions de personnes d’utiliser le XML pour s’échanger des données 

sans le moindre arbitrage. Plus généralement, les technologies XML tentent de fonctionner 

le plus correctement possible même si les données ne correspondent pas à ce 

qu’on attendait. 

Plus généralement, le XML respecte plusieurs principes fondamentaux qui lui accorde 

plusieurs bénéfices. 

– Il est facile d’entretenir et modifier au fil du temps une application basée sur XML. 

CC BY-NC-SA


– Le XML est modulaire : on peut décomposer les applications en plusieurs fichiers, 

on peut traiter séparément différents morceaux d’un même document XML. 

– Les spécifications XML minimisent la redondance sans la réduire à néant : il y a 

plusieurs façons de faire une même chose en XML, mais ce nombre est généralement 

limité. On a souvent le choix entre plusieurs stratégies, mais pas un trop grand 

nombre. 

– Les technologies XML tiennent compte des personnes ayant des handicaps, notamment 

parce que plusieurs modes de présentation sont possibles. 

– Le XML ne dépend pas d’une plate-forme particulière : que vous utilisiez Linux, 

Mac OS ou Windows, vous pouvez travailler avec le XML. 

– Le XML est international : le XML supporte toutes les langues, pas seulement l’anglais. 

– Le XML est extensible : on peut facilement faire évoluer les formats sans avoir à 

réécrire tous nos logiciels. 

– Il est facile d’apprendre le XML. 

– Il est facile pour un humain de lire du XML. 

– Le XML est efficace : un ordinateur peu puissant peut traiter du XML rapidement. 

– Le XML est un format textuel. 

– Le XML est simple. 

– Le XML assure la pérennité des informations. 

– Le XML permet l’interopérabilité des systèmes. 

– Un document XML peut être réutilisé facilement à plusieurs fins. 

– Le XML est stable : les spécifications ne changent pas trop souvent. 

– Le XML est universel : c’est un métalangage qui s’applique à un grand nombre de 

problèmes. 

1.4.5 Conclusion 

Le XML n’est pas une nouveauté scientifique. Le XML représente, par contre, un pas 

en avant parce que c’est un des rares méta-langages universel. Le XML est aussi fondé 

sur des principes importants comme la pérennité, la simplicité, etc. qui ne sont pas 

toujours présents en technologie de l’information. 

1.4.6 Questions d’auto-évaluation 

1. Parmi les affirmations suivantes, lesquelles s’appliquent à un document XML 

Choisissez toutes les réponses qui s’appliquent. 

(a) Contient du texte. 

(b) Contient des balises. 

(c) Peut être affiché par certains navigateurs. 

(d) Exige des logiciels conçus spécifiquement pour le XML. 

2. Parmi les applications suivantes, lesquelles peuvent s’effectuer efficacement avec 

le XML Choisissez toutes les réponses qui s’appliquent. 

CC BY-NC-SA


(a) Incorporer de la musique ou des vidéos. 

(b) L’échange de données entre les serveurs Internet. 

(c) Servir de format pour les logiciels de traitement de texte. 

3. Qu’est-ce qu’on veut dire quand on affirme que le XML est un métalangage 

Choisissez la bonne réponse parmi les choix suivants. 

(a) On peut l’utiliser aussi bien en anglais qu’en français. 

(b) On peut l’utiliser aussi bien avec Java, Perl, Python, C, C# ou C++. 

(c) Il n’y a pas d’ensemble de balises prédéfinies. 

4. Que signifie le « X » de XML Choisissez la bonne réponse parmi les choix 

suivants. 

(a) eXtraordinaire. 

(b) eXtensible. 

(c) eXceptionnel. 

5. Quelles affirmations s’appliquent à un document XML bien formé Choisissez 

toutes les réponses qui s’appliquent. 

(a) Il peut être lisible : un être humain peut plus facilement en comprendre le 

contenu que s’il était mal formé. 

(b) Il respecte la grammaire XML. 

(c) Il peut être lu par n’importe quel parseur XML générique. 

6. Laquelle des affirmations suivantes décrit une application XML Choisissez la 

bonne réponse parmi les choix suivants. 

(a) Il s’agit d’un programme logiciel utilisant XML. 

(b) Un jeu de balises favorisant l’interopérabilité. 

(c) Une application XML est nécessairement un document XML. 

7. Parmi ces affirmations, lesquelles s’appliquent à un document XML valable 


(a) Cela signifie seulement qu’il est bien formé. 

(b) Il correspond à une application XML. 

(c) Un document XML valable a reçu une certification par le W3C. 

(d) Les documents XML doivent être valables. 

(e) Il est bien formé. 

(f) Il respecte toutes les contraintes d’une application XML. 

8. Un document XML peut... Choisissez toutes les réponses qui s’appliquent. 

(a) Communiquer avec un serveur. 

(b) Être transmis à un serveur. 

CC BY-NC-SA


(c) Servir de fichier de configuration. 

(d) Servir de base de données. 

9. Le XML vise à remplacer le HTML. Choisissez la bonne réponse parmi les choix 

suivants. 

(a) Vrai. 

(b) Faux 

10. Je suis un des auteurs du XML... Choisissez toutes les réponses qui s’appliquent. 

(a) Tim Bray 

(b) Tim Berners-Lee 

(c) Jon Bosak 

(d) Jon Dvorak 

(e) Jim Gray 

11. Que signifie XML Choisissez la bonne réponse parmi les choix suivants. 

(a) Example Markup Language. 

(b) Extra Markup Language 

(c) eXtensible Markup Language. 

1.4.7 Solutions 

1. (a) (Bonne réponse) Un fichier XML est essentiellement un fichier texte. 

(b) (Bonne réponse) Le XML se caractérise par des balises, par exemple 

, , , . 

(c) (Bonne réponse) En particulier, Mozilla Firefox supporte très bien les diverses 

spécifications XML. 

(d) Comme le XML est un format texte, tout logiciel qui supporte le format 

texte, tel le Bloc-notes de Microsoft, peut être utilisé avec le XML. 

2. (a) Un document XML étant un document de texte, il n’est pas efficace de 

stocker de la musique ou des vidéos dans un format XML. 

(b) (Bonne réponse) Le XML est idéal pour permettre aux serveurs et aux logiciels 

de communiquer entre eux. Le XML n’est pas limité aux documents, 

il peut aussi servir de format pour des données. 

(c) (Bonne réponse) Le XML est un excellent choix de format pour les documents 

en bureautique; les nouvelles versions de Microsoft Office ou d’ 

Open Office utilisent maintenant le XML. 

3. (a) Ce n’est pas ce qu’on veut dire, mais il est vrai que le XML est international. 

(b) Ce n’est pas ce qu’on veut dire, mais il est vrai qu’on peut utiliser XML 

avec Java, Perl, Python, C, C# ou C++. 

CC BY-NC-SA


(c) (Bonne réponse) C’est ce qu’on veut dire. Le choix des balises dépend 

entièrement de l’application. Ainsi, un scientifique utilisera peut-être des 

balises comme , , , alors qu’un comptable 

utilisera peut-être les balises , , . 

4. (a) Non. 

(b) (Bonne réponse) Oui. XML est l’acronyme de eXtensible Markup Language. 

Cela signifie que le XML peut être étendu et appliqué à toutes sortes 

de situations. 

(c) Non. 

5. (a) Non. Un document bien formé n’est pas nécessairement plus lisible par un 

humain. 

(b) (Bonne réponse) Oui. Le XML est doté d’une grammaire, ce qui signifie 

qu’on peut déterminer avec précision ce qui est permis et ce qui ne l’est 

pas dans un document XML. 

(c) (Bonne réponse) Oui. C’est là un des grands avantages du XML : un document 

XML bien formé peut être lu par n’importe quel logiciel XML 

générique. 

6. (a) Non. 

(b) (Bonne réponse) Oui. Le plus souvent, il s’agit d’un groupe d’utilisateurs 

du XML qui s’entendent sur le même ensemble de balises. Par exemple, 

les cuisiniers du monde pourrait s’entendre sur des balises servant à décrire 

des recettes; il s’agirait là d’une application XML. 

(c) Non. 

7. (a) Non. Un document valable sera bien formé, mais un document bien formé 

n’a pas à être valable. 

(b) (Bonne réponse) Oui. Un document valable doit respecter une définition de 

type de document qui documente une application XML spécifique. 

(c) Non. 

(d) Non. Un grand nombre de documents XML ne sont pas valables; par 

contre, ils doivent être bien formés. 

(e) (Bonne réponse) Oui, puisque tout document XML doit être bien formé, 

alors les documents XML valables doivent être bien formés. 

(f) Non, pas nécessairement. Être valable signifie seulement que le document 

répond à certains critères de base de l’application XML. 

8. (a) Non. Un document XML n’est qu’un document. Ce n’est pas un programme 

capable d’agir. 

(b) (Bonne réponse) Oui. On utilise beaucoup le XML pour transporter des 

données d’un serveur à un autre. Le XML étant une syntaxe neutre, qui ne 

dépend pas d’un logiciel particulier, tout le monde pourra le comprendre. 

CC BY-NC-SA


(c) (Bonne réponse) Oui, absolument. De plus en plus d’applications logicielles 

utilisent le XML à cette fin : un programme peut utiliser le XML 

pour y enregistrer de nombreuses informations, comme les options choisies. 

(d) Non. Le XML n’est qu’un format de fichier. On peut utiliser le XML dans 

une base de données relationnelles, par exemple, mais le XML ne possède 

pas en soi les capacités d’une base de données. 

9. (a) Faux, même s’il est possible d’écrire le HTML en XML. 

(b) (Bonne réponse) Vrai. 

10. (a) (Bonne réponse) Oui. Il a d’ailleurs un site web (anglais). 

(b) Non. Berners-Lee est l’inventeur du web; il s’intéresse beaucoup au XML, 

mais il a plutôt utilisé le SGML dans l’élaboration du web. 

(c) (Bonne réponse) Oui. Il a d’ailleurs un site web (anglais). 

(d) Non. Jon Dvorak est un journaliste américain qui n’a pas contribué au 

XML. 

(e) Non. Jim Gray est chercheur chez Microsoft, mais n’est pas l’un des créateurs 

du XML. 

11. (a) Non. 

(b) Non. 

(c) (Bonne réponse) Effectivement. 

1.5 Principes de XML 


Découvrir les grands principes du XML 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation. Ce texte porte 

sur la syntaxe de base du XML. Les notions importantes sont la balise, l’élément, 

l’élément-racine et l’attribut. 

1.5.3 Quelques principes et notions importantes du XML 

Rappelons qu’une balise est un segment de texte commençant par < et se terminant 

par >. Par exemple, est une balise qui marque le début de l’élément vie. Une 

balise commençant par

Principes de XML 27 

Le nom XML de la balise est le texte suivant le symbole < (ou


 

http://www.google.com 

Un moteur de recherche 

 

Dans ce document, il y a trois éléments. Tout d’abord, il y a l’élément-racine qui comprend 

tout ce qui est entre les balises et . La première balise marque 

le début de l’élément-racine. Tout document XML bien formé doit avoir un élémentracine 

et un seul élément-racine. Tous les autres éléments doivent être contenus dans 

cet élément-racine. Dans notre exemple, cet élément a deux sous-éléments : 


et 


On peut ajouter un attribut à un des éléments de la façon suivante : 

et 

Le texte date="aujourd’hui" est un attribut de l’élément-racine avec pour nom « date » 

et comme valeur d’attribut « aujourd’hui ». 

Tout le texte qui ne se trouve pas dans une balise, mais qui se trouve dans l’élémentracine 

se décompose en nœuds de texte. Par exemple, le document suivant contient un 

élément contenant un nœud de texte. 

mon texte 

1.5.4 Points importants dans la syntaxe de base 

Un document XML ne doit avoir qu’un et un seul élément appelé « élément-racine », 

qui doit contenir tous les autres éléments. 

Il faut correctement ouvrir et fermer les éléments en séquence, ainsi 

n’a aucun sens en XML, il faut plutôt écrire ou alors 

. 

Les éléments peuvent eux aussi avoir des attributs, par exemple , 

mais il faut obligatoirement mettre la valeur de l’attribut entre guillemets (") ou apostrophes 

(’). 

CC BY-NC-SA


1.5.5 Dans l’ordre ou dans le désordre 

Dans un document XML, l’ordre dans lequel les éléments sont présentés importe. Par 

exemple, les deux documents XML suivants ne sont pas équivalents. 

 



 

 



 

Par contre, l’ordre dans lequel les attributs sont présentés est sans importance. Les deux 

documents XML suivants sont donc équivalents. 

 

 

1.5.6 Appels d’entités 

Un élément peut contenir du texte, mais ne peut contenir le symbole 

" " 

' ’ 

Ainsi, si le nom de votre compagnie est John&Smith, vous ne devrez pas utiliser un 

élément comme ceci John&Smith; il vous faudra plutôt utiliser 

John&Smith. 

Le texte « ]]> » s’écrit « ]]> ». 

CC BY-NC-SA


On utilise aussi les appels d’entités pour noter les valeurs des attributs. Supposons que 

la valeur d’un attribut est un guillemet suivi d’une apostrophe ("’). Les deux choix 

possibles ne sont pas valables. Dans ce cas, il faudra 

écrire ,


La syntaxe d’une telle instruction de traitement est simple. L’instruction débute par < 

et se termine par >; immédiatement après


1.5.10 La déclaration XML 

La déclaration XML ressemble à s’y méprendre à une instruction de traitement et prend 

la forme . Une déclaration XML n’est pas une balise ou un élément. Le 

contenu d’une déclaration XML comporte généralement au maximum trois attributs : 

version="...", encoding="..." et standalone="...". La version 1.0 du XML est la plus utilisée; 

bien que la version 1.1 existe, elle est fort peu utilisée. Selon l’un des inventeurs 

du XML, Tim Bray, il est peu probable qu’il y ait une version 2.0 du XML . 

Je ne pense pas qu’il y aura de XML 2.0. Les obstacles politiques seraient 

effrayants - tout le monde voudra sa part du gâteau -, et la base 

installée de logiciels qui reconnaissent XML comprend aujourd’hui à peu 

près tous les ordinateurs liés à Internet, donc une transition me semblerait 

trop onéreuse. (Interview de Tim Bray, JDN Développeurs, 29 janvier 

2007) 

On utilise souvent une déclaration XML avec « encoding="ISO-8859-1" » pour 

pouvoir utiliser les accents dans le document : les jeux de caractères Unicode ne 

sont pas toujours supporté par plusieurs outils logiciels n’ayant pas été mis à jour 

au vingt-et-unième siècle; l’utilisation des accents en français sans la déclaration 

« encoding="ISO-8859-1" » peut alors entraîner des problèmes. L’attribut « standalone 

» prend la valeur yes ou no, selon que l’on veut que la DTD externe soit lue ou 

non. Nous traiterons des DTD, plus tard. 

Dans ce cours, nous supposons que vous utilisez un éditeur de texte qui ne supporte 

pas les normes UTF-8 et UTF-16. En conséquence, le document XML suivant ne serait 

pas bien formé, car il utilise des accents : 

 

Jean 

 

Par contre, le document XML qui suit est bien formé : 

 

 

Jean 

 

La déclaration XML doit obligatoirement être au tout début du document ou être 

carrément absente : même un espace n’est pas permis. 

1.5.11 Les espaces 

En XML, les espaces entre les éléments comptent, qu’il s’agisse d’un retour de charriot, 

d’une tabulation ou d’un simple espace. Ainsi, le document suivant se décompose en 

CC BY-NC-SA


7 parties ou nœuds : un élément-racine nommé html qui contient d’abord un nœud de 

texte (le retour de charriot) suivi d’un élément produit contenant le nœud de texte « 1 », 

suivi d’un autre nœud de texte (le retour de charriot), suivi d’un élément serie (vide), 

suivi d’un troisième nœud de texte (le retour de charriot). 

 

1 

 

 

Par contre ce document ne contient que 4 nœuds (3 éléments et 1 nœud de texte) : 

1 

En effet, comme il n’y a pas d’espace ou de retour de charriot entre les balises, il n’y a 

qu’un seul nœud de texte. Si on omet les attributs, les nœuds débutent et se terminent 

généralement avec les balises. 

On peut indiquer que les espaces entre les éléments sont significatifs avec l’attribut 

xml:space qui peut prendre la valeur default ou la valeur preserve. Dans cet exemple, 

on souhaite indiquer que les espaces sont significatifs : 

 

1 

 

 

1.5.12 Les fins de ligne 

Les fichiers de texte sont souvent organisés en lignes. Selon le système d’exploitation, 

il y a plusieurs façon de représenter une fin de ligne. Les systèmes d’exploitation Microsoft 

utilisent deux caractères (« retour de charriot » et « nouvelle ligne ») à la fin de 

chaque ligne. Les autres système utilisent généralement un seul caractère (« nouvelle 

ligne »). Les processeurs XML sont requis de normaliser la situation et de remplacer 

les deux caractères utilisés par les systèmes Microsoft par un seul caractère lors de la 

lecture du fichier. Ainsi, peu importe comment l’on note les fins de ligne, un processeur 

XML ne vera qu’un caractère « nouvelle ligne ». 

1.5.13 Les hyperliens 

Il arrive fréquemment qu’on utilise des hyperliens dans les documents XML. On distingue 

deux types d’hyperliens : les hyperliens contenant une adresse absolue (telle 

que http://domaine.ca/pong.png) et les hyperliens contenant des adresses relatives 

(pong.png). On reconnaît les adresses relatives parce qu’elles ne débutent pas par un 

protocole tel que http ou ftp. Pour compléter les adresses relatives et les transformer 

CC BY-NC-SA


en adresses absolues, on utilise fréquemment l’adresse du document. Ainsi, si le document 

suivant se trouve à l’adresse http://domaine.ca/fichier.xml, alors un logiciel pourra 

charger une image située à l’adresse http://domaine.ca/pong.png : 

 

adresse relative: 

 

 

Le XML permet de spécifier un attribut xml:base qui sert à interpréter les adresses relatives 

remplaçeant l’adresse du document. Le document suivant pointe vers une image 

à l’adresse http://domaine.ca/image/pong.png : 

 

 

 

 

 

1.5.14 Documents bien formés 

Un document XML qui respecte ces règles de base est dit « bien formé ». Pour éviter 

la confusion, il ne faut pas utiliser des synonymes comme « correct ». 

La terminologie utilisée peut sembler très aride. Cependant, la rigueur qu’exige le XML 

est aussi garante de la cohérence. Comme tous les termes sont bien définis, il est plus 

facile de s’entendre entre experts. Comme le XML est surtout utilisé pour la communication 

entre les logiciels, la rigueur évitera plus tard les bogues et les incompréhensions. 

Pouvoir reconnaître un document XML bien formé ou comprendre pourquoi un document 

n’est pas bien formé, permet de s’assurer qu’un logiciel pourra traiter les informations, 

et qu’on saura quoi faire en cas de problème. 


1. Quelles sont les différences entre un attribut et un élément Choisissez toutes les 

réponses qui s’appliquent. 

(a) Un élément peut contenir d’autres éléments, mais un attribut ne peut contenir 

que du texte. 

(b) Tout document XML doit avoir au moins un attribut. 

(c) L’attribut est associé à un élément qu’il vient décrire. 

2. Quelles sont les balises du document suivant 

CC BY-NC-SA


 



 


(a) http://www.google.com, Un moteur de recherche. 

(b) , , , , , 

(c) http://www.google.com, Un moteur de recherche 

3. Lesquels de ces documents sont bien formés (syntaxe élémentaire) Choisissez 


(a) 

 



 

(b) 

 



 

(c) 

 


 

 

(d) 

 


 

 

4. Lesquels de ces documents sont bien formés (attributs) Choisissez toutes les 

réponses qui s’appliquent. 

CC BY-NC-SA


(a) 

(b) 

(c) 

(d) 

 


un engin de recherche 

 

 



 

 



 

 



 

5. Lesquels de ces documents sont bien formés (sujets avancés) Choisissez toutes 

les réponses qui s’appliquent. 

(a) 

(b) 

(c) 

 



 

 



 

 

 

(d) 

CC BY-NC-SA


 

 

(e) 

(f) 

(g) 

(h) 

(i) 

 

 

 

 

 

 

 

 

 

 

6. Voici un document XML. 

 

JeanLaroche 

 

GaetanRoche 

 

 

Choisissez l’arbre qui représente le mieux ce document. Choisissez la bonne 

réponse parmi les choix suivants. 

(a) classe 

– Etudiant 

– prenom 

– Jean 

– nom 

– Laroche 

– Etudiant 

– prenom 

– Gaetan 

CC BY-NC-SA


– nom 

– Roche 

(b) classe 

– etudiant 

– prenom 

– Jean 

– nom 

– Laroche 

– etudiant 

– prenom 

– Gaetan 

– nom 

– Roche 

(c) classe 

– prenom 

– etudiant 

– Jean 

– etudiant 

– Gaetan 

– nom 

– etudiant 

– Roche 

– etudiant 

– Laroche 

7. Quels sont les noms des attributs dans le document suivant 

 



 


(a) categorie, type 

(b) "recherche", "court texte" 

(c) pageweb, lien, description 

(d) , , , , , 

8. Quelles sont les balises du document suivant 

 



 

CC BY-NC-SA






(d) , , , , , 

9. Quels sont les noms des éléments du document suivant 

 



 





(d) , , , , , 

10. Je suis un appel d’entité propre à tous les documents XML. 


(a) < 

(b) & 

(c) &pluspetit; 

(d) > 

(e) " 

(f) &guillemet; 

(g) ' 

11. Pourquoi a-t-on besoin d’appel d’entités en XML 


(a) Parce qu’on ne pourrait pas utiliser le symbole < dans le contenu textuel 

d’un élément; en effet, il marque le début d’une balise. 

(b) Parce qu’on ne pourrait pas utiliser le symbole > dans le contenu textuel 

d’un élément; en effet, il marque la fin d’une balise. 

(c) Parce que les caractères , ’, ", & sont interdits dans le contenu textuel 

d’un élément. 

CC BY-NC-SA


12. Lesquels de ces documents sont bien formés Choisissez toutes les réponses qui 

s’appliquent. 

(a) 

(b) 

(c) 

(d) 

 

caissier 

>10,000$ 

 

 

5 mois ou "presque" 

10,000$ 

 

 

magasinier 

>Daniel Lemire 

professeur 

 

 

Daniel Lemire 

professeur 

 

CC BY-NC-SA


(c) 

(d) 

(e) 

(f) 

 

Daniel Lemire 

professeur 

 

 

Daniel Lemire 

professeur 

 

 

Daniel Lemire --> 

professeur 

 

 

 

Daniel Lemire 

professeur 

 

14. Lesquels de ces documents contenant des instructions de traitement sont bien 

formés (Rappelons qu’en XML, une instruction de traitement prend la forme 

avec la contrainte que le nom de l’instruction de traitement 

ne peut commencer par xml. 


(a) 

(b) 

 

Daniel Lemire 

professeur 

 

 

DanielLemire 

professeur 

 

CC BY-NC-SA


(c) 

 

 

Daniel Lemire 

professeur 

 

15. Lesquels de ces documents contenant une déclaration sont bien formés (Rappelons 

qu’en XML, la déclaration prend une forme similaire à une instruction de 

traitement, mais débute par xml, comme ceci . L’attribut 

version indique la version du métalangage XML utilisée et, dans ce cours, nous 

utilisons toujours la version 1.0.) Choisissez toutes les réponses qui s’appliquent. 

(a) 

(b) 

(c) 

 

 

Daniel Jacques 

bibliothéconomie 

 

 

 

 



 

 

 

 



 

16. Quelle forme doit prendre la déclaration XML Choisissez la bonne réponse 

parmi les choix suivants. 

(a) 

(b) 

(c) 

17. Est-ce que ce document est bien formé 

CC BY-NC-SA


 

 

 


(a) Vrai 

(b) Faux 

18. Un élément ne peut pas être vide en XML 


(a) Vrai 

(b) Faux 

19. Lequel de ces noms n’est pas permis pour un élément en XML 


(a) x1 

(b) 1x 

(c) Nx 

20. Lequel de ces noms est permis pour un élément en XML 


(a) xmlcourse 

(b) 7eleven 

(c) Joe Louis 

(d) Aucune de ces réponses 

21. Le XML préserve les espaces entre les éléments. Choisissez la bonne réponse 


(a) Vrai 

(b) Faux 

22. Combien de nœuds de texte contient le document suivant 

 

 

 



 


CC BY-NC-SA


(a) 2 

(b) 5 

23. Il peut y avoir des nœuds de texte avant le début de l’élément-racine. 


(a) Vrai 

(b) Faux 

24. Il peut y avoir des nœuds de texte après la fin de l’élément-racine. 


(a) Vrai 

(b) Faux 

25. Un document qui comporte 12 balises doit avoir 6 éléments. 


(a) Vrai 

(b) Faux 

26. Considérons un document qui ne comporte que des élements et du texte, sans 

entités, sans instructions XML, etc. S’il comporte 12 balises, il peut avoir 12 

nœuds de texte 


(a) Vrai 

(b) Faux 


1. (a) (Bonne réponse) Correct. Dans ce sens, on peut dire qu’un élément est un 

concept plus général et plus riche. 

(b) C’est faux. Le document XML suivant n’a pas d’attribut: 

 



 

(c) (Bonne réponse) Correct. Un attribut dépend d’un élément donné, alors 

qu’un élément peut n’appartenir à aucun autre élément, s’il est l’élémentracine. 

2. (a) Non. Il s’agit là du contenu de deux éléments. 

(b) (Bonne réponse) Effectivement! 

CC BY-NC-SA


(c) Non. Il s’agit là de deux éléments. 

3. (a) (Bonne réponse) C’est un document XML valable. 

(b) Non. La balise de fermeture a une casse différente de la balise 

d’ouverture . 

(c) (Bonne réponse) La balise indique qu’il n’y a pas de 

contenu pour l’élément description ce qui est équivalent à . 

(d) (Bonne réponse) L’élément indique qu’il n’y 

a pas de contenu pour l’élément description, ce qui est équivalent à . 

4. (a) (Bonne réponse) Le texte categorie=’recherche’ signifie que l’élément possède 

l’attribut categorie ayant la valeur "recherche". 

(b) Le texte categorie=recherche n’est pas valable parce que la valeur d’attribut 

n’est pas entre guillemets ou apostrophes. 

(c) Une balise de fermeture, comme , ne 

peut avoir d’attribut. 

(d) (Bonne réponse) Le texte categorie="recherche" signifie que l’élément pageweb 

possède l’attribut categorie ayant la valeur "recherche", alors que le 

texte categorie="url" signifie que l’élément lien possède l’attribut categorie 

ayant la valeur "url". 

5. (a) (Bonne réponse) Effectivement. On peut avoir plusieurs attributs pour un 

élément. 

(b) Non. On ne peut avoir deux attributs portant le même nom pour un élément. 

(c) Non. Le symbole « $ » n’est pas permis dans le nom d’un attribut. 

(d) (Bonne réponse) Oui. On peut utiliser n’importe quelle chaîne de caractères 

comme valeur d’attribut. 

(e) Le symbole « » n’est pas permis dans le nom des attributs. 

(f) (Bonne réponse) Oui. Le symbole point (.) est permis dans le nom des 

attributs, en autant qu’il ne soit pas le premier caractère. 

(g) Le symbole point (.) est permis dans le nom des attributs, en autant qu’il 

ne soit pas le premier caractère. 

(h) (Bonne réponse) Oui. Les chiffres sont permis dans le nom des attributs, en 

autant qu’ils ne soient pas les premiers caractères. 

(i) Non. Les chiffres sont permis dans le nom d’un attribut en autant qu’ils 

ne soient pas les premiers caractères. 

6. (a) Non. Le document XML a un élément « etudiant », pas « Etudiant ». La 

casse est importante en XML. 

(b) (Bonne réponse) Oui! 

(c) Non. La structure du document XML est classe -> etudiant -> nom/prenom. 

7. (a) (Bonne réponse) Effectivement! 

CC BY-NC-SA


(b) Non. Il s’agit là de la valeur des attributs. 

(c) Non. Il s’agit là du nom des éléments. 

(d) Non. Il s’agit là du nom des balises. 

8. (a) Non. Il s’agit là du nom des attributs. 


(c) Non. Il s’agit là du nom des éléments. 

(d) (Bonne réponse) Oui. Il s’agit là du nom des balises. 

9. (a) Non. Il s’agit là du nom des attributs. 


(c) (Bonne réponse) Oui. Il s’agit là du nom des éléments. 

(d) Non. Il s’agit là du nom des balises. 

10. (a) (Bonne réponse) Oui. Je représente le caractère . 

(e) (Bonne réponse) Oui. Je représente le caractère ". 

(f) Non. Les guillemets sont représentés par " . 

(g) (Bonne réponse) Oui. Je représente le caractère ’. 

11. (a) (Bonne réponse) Oui. Cet élément n’est pas bien formé : . 

(c) Non. Seuls les caractères < et & sont interdits. 

12. (a) (Bonne réponse) Oui. Le symbole > est permis. 

(b) (Bonne réponse) Oui. Les guillemets sont permis. 

(c) Non. Il faut remplacer < par &lt. 

(d) Non. Il faut remplacer & par &. 

13. (a) Non. Il n’est pas permis d’avoir un commentaire dans une balise. 

(b) (Bonne réponse) Oui. La partie est un commentaire. 

(c) (Bonne réponse) Oui. La partie est un commentaire 

où le symbole < est permis. 

(d) Non. Il n’est pas permis d’avoir deux tirets dans un commentaire. 

(e) Non. Il n’est pas permis d’avoir un commentaire dans un commentaire. 

(f) (Bonne réponse) Oui. Il est permis d’avoir un commentaire avant la première 

balise (début de l’élément-racine). 

CC BY-NC-SA


14. (a) Non. Il n’est pas permis d’avoir une instruction de traitement dans une 

balise. 

(b) (Bonne réponse) Oui. On peut mettre une instruction de traitement au sein 

d’un élément XML. 

(c) (Bonne réponse) Oui. On peut mettre une instruction de traitement avant la 

première balise (début de l’élément-racine). 

15. (a) (Bonne réponse) Oui. Observez que l’attribut « encoding » nous permet de 

spécifier la norme ISO-8859-1 qui, en pratique, signifie qu’on peut utiliser 

tous les caractères de la langue française, même dans les noms de balise. 

Par défaut, seuls les caractères de la langue anglaise sont permis (pas d’accent). 

(b) Non. Une seule déclaration XML est permise. 

(c) Non. La déclaration doit apparaître au tout début du document. 

16. (a) Non. 

(b) Non. 


17. (a) Non. La valeur de l’attribut doit être entre guillemets. 

(b) (Bonne réponse) Effectivement. 

18. (a) Non. Il peut être vide. 

(b) (Bonne réponse) Effectivement. Il peut être vide. 

19. (a) Oui, c’est permis. 

(b) (Bonne réponse) Ce n’est pas permis parce qu’il début par un chiffre. 

(c) C’est permis. 

20. (a) Un nom d’élément ne peut débuter par xml. 

(b) Ce n’est pas permis parce qu’il début par un chiffre. 

(c) Les espaces ne sont pas permis. 

(d) (Bonne réponse) Effectivement. 

21. (a) (Bonne réponse) Effectivement. 

(b) Les espaces peuvent avoir beaucoup d’importance en XML. 

22. (a) Il y en a davantage. 

(b) (Bonne réponse) En effet, il faut compter un nœud après le début de l’élément 

étudiant, mais avant le début de l’élément nom. Puis, il y a le texte 

Daniel Jacques. Ensuite, il y a un nœud de texte après la fin de l’élément 

nom et avant le début de l’élément cours. Puis, il y a le texte bibliothéconomie. 

Finalement, il y a un nœud de texte après l’élément cours, mais avant 

la fin du document. 

23. (a) Non, ce n’est pas possible. 


CC BY-NC-SA


24. (a) Non, ce n’est pas possible. 


25. (a) Non. Il pourrait y avoir jusqu’à 12 éléments vides. 


26. (a) Non. Un nœud de texte doit apparaître entre deux balises. On ne peut donc 

avoir plus de 11 nœud de texte. 


1.6 Définition de type de document 


Comprendre la notion de type de document et son rôle dans la définition de document 

valable. 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation. Ce texte traite 

des définitions de type de document (DTD) qui servent à définir les documents XML 

valables. 

1.6.3 Document XML valable 

Nous avons vu ce qu’était un document XML bien formé : un seul élément-racine, les 

éléments ne se chevauchent pas, les noms XML ne commencent pas par un chiffre, et 

ainsi de suite. De plus, un document XML bien formé peut contenir n’importe quel élément 

et dans n’importe quel ordre, et tous les éléments peuvent contenir des attributs, 

et peu importe ceux-ci. 

En pratique, il est souvent suffisant pour les documents XML d’être bien formés, mais 

il arrive qu’on veuille imposer des contraintes supplémentaires aux éléments et attributs 

pouvant être utilisés. Par exemple, un élément « étudiant » pourrait posséder un 

numéro d’étudiant, mais pas l’inverse : un élément « numéro d’étudiant » ne pouvant 

contenir qu’un numéro et pas d’autres éléments. On peut aussi vouloir contraindre le 

contenu d’un document XML pour des raisons d’interopérabilité. Par exemple, si un 

groupe d’experts s’entendent sur un format XML pour un type de données, il est utile 

de pouvoir vérifier si un fichier XML donné correspond bien à ce sur quoi on s’est entendu. 

Un document XML qui est bien formé et qui respecte les contraintes définissant 

son type de document est dit valable (ou valide). 

CC BY-NC-SA

Définition de type de document 49 

En d’autres mots, un document XML qui est bien formé et qui, en plus, satisfait aux 

contraintes dictant quels éléments et attributs peuvent être utilisés, et dans quel ordre 

et avec quel contenu, est dit valable. 

1.6.4 Normes de définition de type de document 

Il y a plusieurs façons de définir des types de documents XML. L’approche la plus 

répandue, la plus ancienne et la plus simple, est la norme de définition de type de 

document (DTD). C’est la seule approche présentée dans ce cours. Les deux autres 

possibilités émergentes les plus répandues sont XML Schema et Relax NG. 

On fait généralement deux reproches à l’approche DTD : un document DTD n’est pas 

du XML et la norme n’est pas assez riche pour spécifier le contenu des documents 

XML avec finesse. En effet, L’approche DTD ne permet pas de déclarer qu’un contenu 

textuel doit être une date ou un nombre, et il n’y a pas de support pour les espaces de 

noms, sujet que nous traiterons plus loin dans ce module. 

D’un autre côté, la norme DTD est très répandue et tous les logiciels qui supportent 

XML supportent maintenant cette norme, incluant Java et Firefox. Les nouveaux formats 

comme XHTML 2.0 sont toujours publiés avec une spécification DTD. Les autres 

possibilités, comme XML Schema, Relax NG, Schematron et Examplotron, sont moins 

bien supportées. 

La norme XML Schema permet de définir avec une grande finesse des types de données 

comme une date ou un code de langue (« fr », « en »). Cette norme est très utile si on 

veut spécifier avec beaucoup de détail le format de nos documents XML. Comme vous 

pouvez le constater dans l’exemple suivant, la norme XML Schema permet non seulement 

de spécifier le nom des éléments et des attributs (« shipTo », « billTo », « comment 

», « items », « orderDate »), mais aussi leur type (« xsd:string », « xsd:decimal », 

« xsd:date »). 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA


 

 

 

La norme XML Schema est supportée en Java depuis la version 1.5. Il n’est pas nécessaire 

d’utiliser une librairie spécialisée.Elle est cependant sujette à des critiques très 

sévères de la part des experts en XML tels que Tim Bray (co-inventeur du XML) qui 

écrivait en novembre 2006 sur son blogue : 

Everybody who actually touches the technology has known the truth 

for years, and it’s time to stop sweeping it under the rug. W3C XML Schemas 

(XSD) suck. They are hard to read, hard to write, hard to understand, 

have interoperability problems, and are unable to describe lots of things 

you want to do all the time in XML. Schemas based on Relax NG, also 

known as ISO Standard 19757, are easy to write, easy to read, are backed 

by a rigorous formalism for interoperability, and can describe immensely 

more different XML constructs. 

En somme, XML Schema est trop difficile à utiliser et à comprendre. Tim Bray, ainsi 

que de nombreux autres experts, préconisent plutôt l’utilisation de Relax NG. Cette 

norme, comme XML Schema, possède plusieurs avantages sur la norme DTD : elle 

permet de spécifier des types de données (comme une date ou un nombre), supporte 

les espaces de noms, etc. De plus, la norme Relax NG est plus élégante techniquement 

et parfois plus simple que la norme XML Schema. Des formats importants comme 

l’Open Document Format, DocBook (format XML), TEI, XHTML 2.0 et Atom sont 

définis par RelaxNG plutôt que par XML Schema. (Une définition XML Schema sera 

sans doute produite pour le format XHTML 2.0.) Relax NG dispose aussi d’une syntaxe 

« compacte », qui n’est pas en XML contrairement au format par défaut de Relax NG, 

et que nous allons utiliser dans nos exemples. Voici un exemple de Relax NG : 

element addressBook { 

element card { 

element name { text }, 

element email { text } 

}* 

} 

Cet exemple spécifie que le document XML doit avoir comme élément racine un élément 

« addressBook », contenant zéro ou plus éléments « card ». Un élément « card » 

doit obligatoirement contenir un élément « name » suivi d’un élément « email ». On 

trouve facilement des tutoriels de qualité sur Relax NG. L’un meilleur tutoriel est en 

anglais à l’adresse http://relaxng.org/compact-tutorial-20030326.html. 

Tout en étant plus élégante que la norme DTD, le format Relax NG est plus limitée que 

XML Schema puisqu’il ne permet que quatre types de contraintes sur le nombre d’occurences 

d’un élément (zeroOrMore comme dans notre exemple, optional, un nombre 

précis (comme une seule fois) et oneOrMore) alors que le XML Schema permet des 

contraintes beaucoup plus spécifiques. Cependant, la richesse de la norme XML Schema 

CC BY-NC-SA


a un coût : il s’agit d’une norme beaucoup plus difficile à utiliser et à apprendre en pratique. 

On peut valider un document XML par rapport à une définition RelaxNG avec la librairie 

Jing (http://www.thaiopensource.com/relaxng/jing.html). 

On peut passer automatiquement d’un document DTD à un document XML Schema ou 

Relax NG avec un outil comme NekoDTD (http://people.apache.org/ andyc/neko/doc/ 

dtd/conversions.html). 

En somme, la norme DTD n’est sans doute pas ce qui se fait de mieux, mais c’est 

de loin la norme la plus utilisée historiquement, et c’est celle que nous allons étudier 

en détail. Pour certaines applications, la norme DTD demeure supérieure aux alternatives 

mentionnées précédemment: la définition d’entités n’est pas possible en XML 

Schema ou Relax NG, par exemple. Si vous maîtrisez la norme DTD, vous n’aurez 

aucun mal à utiliser une autre norme comme Relax NG puisque les principes essentiels 

sont les mêmes. Notez que la webographie contient quelques liens vers les normes 

XML Schema et Relax NG. 

1.6.5 Documents valables utilisant la norme DTD 

Un document valable commence par une déclaration XML, comme celle qui suit : 

 

Elle est suivie d’une déclaration de type de document sous la forme , où l’on remplace les premiers trois points par le 

nom XML de l’élément-racine que le document doit avoir, et les deuxièmes 

trois points par une URL vers le document DTD. L’URL peut être absolue, 

comme « http://www.google.com/mydtd.dtd », ou locale, comme « madtd.dtd » 

ou « ../dtd/madtd.dtd ». Dans le second cas, il faut que le fichier DTD soit sur 

le disque, à l’endroit indiqué par rapport au fichier XML. Ainsi, dans l’exemple 

« ../dtd/madtd.dtd », il faudrait que le fichier « madtd.dtd » soit dans le répertoire 

« dtd », voisin du répertoire où se trouve le fichier XML. Ainsi, immédiatement après 

la déclaration XML, on pourrait avoir le texte suivant : 

 

où « baliseracine » est le nom de l’élément-racine du document, alors que le chemin 

« http://www.mondomain.com/madtd.dtd » nous dit où trouver le document DTD. 

Rappelons que l’attribut « encoding » nous donne le jeu des caractères. On choisit 

souvent « ISO-8859-1 », mais par défaut, XML utilise un jeu de caractères Unicode 

(UTF-8). Si le contenu est en français (avec les accents), il est essentiel que le fichier 

soit enregistré avec le jeu de caractères déclaré sinon on pourra constater des messages 

d’erreurs ou des accents manquants. L’attribut « standalone » permet au logiciel de 

décider, s’il est nécessaire, d’aller chercher la DTD externe avant de lire le fichier XML, 

CC BY-NC-SA


même si, très souvent, un logiciel tel Mozilla Firefox ignore la consigne et ne va pas 

chercher la DTD externe. En gros, s’il y a une DTD externe, on utilisera l’attribut 

« standalone="no" », autrement on utilise « standalone="yes" ». 

1.6.6 La syntaxe des documents DTD 

Les documents DTD contiennent des instructions de la forme . Bien 

que celle-ci ait l’apparence d’une balise XML, ce n’est pas du XML. Dans une instruction, 

on met d’abord un nom XML qui correspond à un nom d’élément : par exemple, 

l’instruction « » définira ce qui peut être contenu dans 

un élément de nom « montant ». Tout ce qui suit le nom de l’élément dicte ce que 

l’élément peut contenir. Le plus souvent, on place la description du contenu entre parenthèses 

(« »), sauf pour les cas particuliers 

(« ANY » et « EMPTY ») définis plus loin. De façon courante, on définit le contenu 

d’un élément par une liste de noms XML, correspondant à des noms d’élément et séparés 

par des virgules. Par exemple, l’instruction « » nous informe qu’un élément « montant » doit contenir un élément « devise » suivi 

d’un élément « valeur ». Notons que l’ordre des éléments importe et que les instructions 

« » et « » ne sont pas équivalentes. 

Bien qu’on ne puisse exprimer toutes les possibilités, la syntaxe DTD permet tout de 

même de spécifier un grand nombre de règles. Par exemple, le symbole « » permet de 

spécifier qu’un élément peut être présent ou non (élément optionnel). Ainsi, l’instruction 

« » signifie que l’élément « montant » 

peut contenir un élément « devise » (ou non) et doit contenir un élément « valeur ». 

Si jamais l’élément « devise » apparaît, il doit apparaître avant l’élément « valeur ». 

Si jamais on veut qu’un élément soit optionnel et que, s’il apparaît, il puisse apparaître 

plus d’une fois, on utilise le symbole « * ». Ainsi, l’instruction « » signifie qu’on peut avoir zéro, un ou plusieurs éléments « devise », 

puis un élément « valeur ». De la même façon, le symbole « + » est utilisé pour spécifier 

qu’un élément doit être présent, mais peut apparaître plus d’une fois. 

Au lieu d’utiliser la virgule, on peut utiliser le symbole « | » pour spécifier qu’un élément 

ou un autre peut apparaître. Ainsi, l’instruction « » signifie que l’élément « montant » peut contenir soit l’élément « devise 

», soit l’élément « valeur » (l’un ou l’autre, mais pas les deux ou aucun des deux). 

Finalement, on peut combiner le tout; par exemple, l’instruction « » signifie que l’élément « montant » peut contenir au moins un 

élément « devise » (et rien d’autre) ou alors, aucun, 1 ou plusieurs éléments « valeur ». 

Si jamais on veut qu’un élément puisse contenir du texte, on utilise le terme technique 

« #PCDATA » dans l’instruction DTD. Par exemple, l’instruction « » signifie que l’élément « montant » contient du texte et seulement 

du texte (pas d’éléments). Supposons maintenant qu’on veut permettre du contenu 

mixte, comme dans l’exemple qui suit : 

CC BY-NC-SA


 

Ceci est du contenu mixte 

parce qu’il s’agit de mélange de texte et de 

balises. 

 

On pourrait penser que l’instruction « » 

permettra du texte ou des éléments « important », et c’est vrai; mais elle permet l’un 

(juste du texte) ou l’autre (juste un élément « important »), mais pas un mélange des 

deux. Pour pouvoir obtenir le résultat désiré, soit un mélange d’éléments « important » 

et de texte, il faut permettre la répétition du choix, comme dans l’instruction « ». Il s’agit de la seule façon de spécifier qu’on 

permet un mélange de texte et d’éléments (contenu mixte). 

Voyons un autre exemple de contenu mixte. Considérons l’instruction « ». Ce qu’elle signifie exactement, c’est que les éléments 

« montant » peuvent contenir un mélange de texte et des éléments « devise », comme 

l’exemple qui suit : 

 

Le montant est spécifié en dollars. 

 

On peut aussi utiliser « ANY » pour spécifier qu’un élément peut contenir n’importe 

quoi (n’importe quelle séquence d’éléments déclarés dans la DTD et du texte) ou 

« EMPTY » pour spécifier qu’un élément doit être vide (sans même un seul espace). 

C’est le seul cas où l’on n’utilise pas de parenthèses lors de la définition du contenu, 

comme dans ces exemples : et . 

Un document DTD prendra donc la forme d’un fichier en format texte contenant une 

suite d’instructions comme : 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA


Notez qu’on écrit rarement de nouvelles DTD : dans un domaine particulier, il existera 

souvent des DTD déjà utilisées; sinon, on fera l’effort de les créer, mais qu’une seule 

fois. L’important demeure toutefois de pouvoir lire et comprendre les DTD. 

1.6.7 Exemple supplémentaire 

Pour s’assurer de bien comprendre, voyons un autre exemple : 

 

 

 

 

Cette DTD nous spécifie que l’élément « lettre » contient du mélange de texte et d’éléments 

« personne » (contenu mixte), alors que l’élément « personne » doit contenir un 

élément « age », suivi d’un élément « nom ». 

Par exemple, ce document XML serait valable : 

 

 

 

 

]> 

 

Ceci est une lettre pour 

51Jean. 

 

Assurez-vous de bien comprendre pourquoi ce document est valable avant de continuer. 

1.6.8 Les attributs 

Par défaut, aucun élément n’est autorisé à avoir un attribut. Pour permettre d’ajouter un 

attribut à un élément, il faut une instruction de la forme qui spécifie que l’élément recipiendaire peut avoir un attribut « age ». On permet généralement 

aux valeurs d’attribut de contenir n’importe quel texte, ce qu’on représente 

par « CDATA ». Hormis le contenu, il existe deux types d’attributs : les attributs obligatoires 

(« #REQUIRED ») et les attributs optionnels (« #IMPLIED »). Par exemple, 

l’instruction « » signifie qu’on 

CC BY-NC-SA


peut (ou pas) accorder à un élément « recipiendaire » un attribut nommé « age » pouvant 

contenir n’importe quel texte. Si l’on désire que l’attribut soit obligatoire, on utilise 

une instruction comme « ». 

Si l’on veut permettre à un élément d’avoir plusieurs attributs, on peut le faire en utilisant 

plusieurs instructions comme dans « »; on peut aussi 

combiner les instructions dans une seule : « ». Cependant, il n’est pas possible de spécifier 

l’ordre dans lequel les attributs doivent apparaître, les instructions « » et « » sont 

équivalentes. 

L’attribut « xml:lang » utilisé pour définir la langue d’un texte, peut être déclaré comme 

ceci : « ». L’attribut xml:space 

peut être déclaré comme ceci : « ». 

On peut également spécifier qu’un élément donné a toujours un attribut donné (indiqué 

ou non dans le XML) comme ceci : « ». Dans ce dernier exemple, tous les éléments « recipiendaire » ont l’attribut 

« age="40 ans" », même si on omet de l’indiquer dans la balise de départ de l’élément 

« recipiendaire ». 

Plus simplement, on peut spécifier une valeur par défaut qui ne prendra effet que si 

l’on n’a pas explicitement indiqué l’attribut. Par exemple, l’instruction « » signifie que l’élément « recipiendaire » aura 

l’attribut « age="40 ans" », à moins qu’on ne spécifie autre chose dans le XML. 

Il peut être utile de donner une liste de valeurs que pourra prendre un attribut. Par 

exemple, une pièce de monnaie est soit sur « face », soit sur « pile » : il n’y a que 

deux choix. Si la liste de choix est composée de textes sans espace ou ponctuation, 

sauf la barre du soulignement ( _ ), le trait d’union ( - ) et le point ( . ), alors on peut 

faire une énumération comme dans l’exemple suivant : « ». On peut aussi spécifier une valeur par défaut, si l’on suppose, 

jusqu’à preuve du contraire, que la pièce est dans la position « face », comme 

ceci « » 

On peut également spécifier qu’un attribut servira à identifier un élément de façon 

unique. Pour ce faire, on utilise une instruction comme « ». Il n’est pas possible, pour deux attributs de type ID, d’avoir la même valeur 

dans un même document XML. En somme, si l’on donne une valeur « ID », elle devrait 

correspondre de façon unique à un élément et un seul. Un attribut de type « ID » doit 

avoir comme valeur un « nom XML », c’est-à-dire un texte sans espace ou ponctuation, 

sauf la barre du soulignement ( _ ), le trait d’union ( - ) et le point ( . ), et qui ne 

commence pas par un chiffre, un trait d’union ou un point. 

CC BY-NC-SA


On peut faire référence aux attributs de type « ID » avec des attributs de 

type « IDREF ». La valeur d’un attribut « IDREF » doit non seulement être un 

nom XML, mais doit aussi avoir un attribut de type « ID » qui possède cette même 

valeur quelque part dans le document XML. Par exemple, si on a l’instruction « », on pourra ensuite faire référence à l’élément ayant 

une valeur d’attribut « code » particulière, avec une instruction comme « ». 

Dans ce contexte, le document XML qui suit n’est pas valable : 

 

 

 

 

 

Par contre, l’exemple qui suit est valable : 

 

 

 

 

 

Il existe d’autres types d’attributs, mais ils sont peu utilisés. 

1.6.9 Les entités 

Vous vous rappelez sans doute que le XML définit quelques entités par défaut, « < », 

par exemple. On peut toutefois définir ses propres entités avec une instruction DTD 

comme celle-ci : 

 

La signification de ce dernier exemple, c’est que partout où « &monentite; » apparaît 

dans un document, il sera remplacé par le texte « Introduction à XML ». Ce remplacement 

s’applique aussi aux valeurs par défaut des attributs de la DTD. 

On peut mettre des éléments et des attributs dans une entité comme dans cet exemple : 

 

Il n’est cependant pas permis de ne mettre qu’une partie d’un élément comme ceci : 

 

CC BY-NC-SA


Une entité peut faire appel à une autre entité : 

 

 

Une entité ne peut cependant pas faire appel à elle même de manière récursive, directement 

ou indirectement. Cet exemple n’est donc pas valable : 

 

 

1.6.10 DTD interne et externe 

Normalement, on fait référence à un document DTD à l’aide d’une URL, c’est ce qu’on 

appelle la DTD externe. Mais il est possible d’ajouter ses propres instructions DTD 

directement dans le document XML, en ajoutant une DTD interne qui est lue avant la 

DTD externe. 

Prenons l’exemple suivant, soit un document XML qui débute par : 

 

 

Dans ce cas, tout ce passe comme si on ajoutait la ligne « » à la DTD externe. Normalement, il ne devrait jamais y avoir de conflit entre 

les deux DTD (interne et externe); on ne peut pas redéfinir un élément, mais on peut 

y définir des éléments! 

Par contre, les entités peuvent être redéfinies et la définition trouvée dans le DTD interne 

l’emporte. 

On peut même omettre complètement la DTD externe comme dans l’exemple suivant : 

 

 

 

]> 

CC BY-NC-SA


1.6.11 Les entités paramètres 

On peut aussi définir des entités particulières qui ne s’appliquent que dans le contexte 

de la DTD, et non pas dans le document XML. Pour ces entités, au lieu d’utiliser 

l’esperluette ( & ), on utilise plutôt le symbole du pourcentage ( % ). Ainsi, l’instruction 

suivante : 

 

signifie que partout, dans la DTD externe, où se trouve le texte « %monentite; », il sera 

remplacé par « #PCDATA|age* »; on appelle ces entités des « entités paramètres ». On 

peut définir une entité paramètre dans la DTD interne, mais on ne peut pas l’y utiliser; 

elle doit être utilisée dans la DTD externe. Si l’entité paramètre « %monentite; » est 

définie, à la fois dans la DTD interne et dans la DTD externe, la DTD interne a préséance. 

En somme, les entités paramètres ne s’appliquent que dans la DTD externe; 

elles ne s’appliquent ni dans le document XML, ni dans le DTD interne, soit la partie 

de la DTD définie dans le document XML. 

1.6.12 Commentaires dans les fichiers DTD 

Pour rendre un fichier DTD plus compréhensible, on peut ajouter des commentaires. 

La syntaxe est la même que pour les fichiers XML comme le montre l’exemple suivant. 

 

 

 

 

 

 

Les commentaires dans les fichiers Relax NG non-textuel sont obtenus en débutant une 

ligne par le symbole « # » comme dans cet exemple. 


# les éléments addressBook contiennent 0, 1, ou plusieurs 

# éléments card 


# les éléments card contiennent un élément 

# name et un élément email 

element name { text }, 

element email { text } 

}* 

} 

CC BY-NC-SA


1.6.13 Une comparaison entre Relax NG et DTD 

Une fois qu’on connaît bien le format DTD, il est facile d’apprendre Relax NG. Prenons 

d’abord un de nos exemples de fichier DTD. 

 

 

 

 

Une étude attentive vous permettra de constater que ce fichier est très similaire au 

fichier Relax NG suivant, qui lui est essentiellement équivalent. 

element lettre { 

# un élément lettre contient 

# du texte et des éléments 

# personne 

(text 

| element personne { 

# un élément personne 

# contient un élément age 

# suivi d’un élément nom 

element age {text}, 

element nom {text}, 

} 

)* 

} 

Pour bien comprendre, prenons un autre exemple, plus complexe cette fois-ci. Voici un 

autre fichier DTD discuté précédemment. 

 

 

 

 

 

 

 

 

 

 

Voici l’équivalent en Relax NG. Si vous l’étudiez avec soin, vous verrez qu’encore une 

fois, le format Relax NG est très similaire au format DTD. 

element problemset { 

CC BY-NC-SA


( 

element title { text } , 

element recall { 

( text 

| element section {text} 

| element codexml {text}) * 

} , 

element item { 

element question {text}, 

element choice { 

element response { text}, 

element feedback {text} 

}+ 

} * 

)* 

} 

Prenons maintenant un exemple de fichier DTD contenant un attribut. 

 

 

 

 

 

 

L’équivalent Relax NG est, encore une fois, assez compréhensible comme vous pourrez 

le constater, l’instruction ATTLIST étant remplacée par l’instruction « attribute ». 

element lettre { 

# un élément lettre contient 

# du texte et des éléments 

# personne 

(text 

| element personne { 

# une élément personne 

# contient un élément age 

# suivi d’un élément nom 

# et, optionnellement, d’un 

# élément estunhomme qui est 

# obligatoirement vide, 

# l’élément personne peut aussi 

# avoir un attribut nas 

attribute nas {text}, 

element age {text}, 

CC BY-NC-SA


} 

)* 

element nom {text}, 

element estunhomme {empty} 

} 

Lorsqu’on utilise l’instruction attribute, la présence de l’attribut est requise à moins 

d’ajouter le point d’interrogation (« ») à la suite de l’instruction. 

Le format Relax NG permet aussi de définir des motifs qui peuvent être réutilisés. 

Prenons ce fichier DTD simple. 

 

 

L’équivalent en Relax NG donne ceci. 

carte = element carte { page } 

page = element page { carte } 

Le format Relax NG a cependant plusieurs avantages. Par exemple, l’esperluette (&) 

permet de spécifier que des éléments puissent être inclus dans n’importe quel ordre. Il 

n’y a pas d’équivalent en DTD. Considérons l’exemple suivant. 



element name { text } 

& element email { text } 

}* 

} 

On peut alors permettre le XML suivant. Il n’est pas possible de spécifier le contenu de 

l’élément card avec une instruction DTD similaire. 

 

Jeanl@c 

l@cJean 

 

Supposons maintenant qu’un élément puisse avoir soit l’attribut nas, soit à la fois les 

attributs nas1 et nas2. Alors qu’il n’est pas possible de représenter cette condition en 

DTD, c’est une chose facile en Relax NG. 

element homme { 

( attribute nas {text} | 

( 

attribute nas1 {text}, 

CC BY-NC-SA


} 

) 

) 

attribute nas2 {text} 

Vous êtes invité à poursuivre vos lectures sur le format Relax NG en faisant des recherches 

sur le web. 

1.6.14 Une approche plus modulaire 

En pratique, les fichiers DTD et Relax NG peuvent devenir complexes. On souhaite 

donc souvent les diviser en plusieurs fichiers plus petits. Par exemple, pour une spécification 

portant des ventes et achats de biens, on pourra avoir un fichier portant sur 

la description des biens, un fichier portant sur la description des acheteurs, et ainsi de 

suite. Une approche modulaire, avec de petits fichiers, a aussi l’avantage qu’on peut 

réutiliser les fichiers dans plus d’une spécification. 

À titre d’exemple, reprenons le fichier DTD portant sur la définition de l’élément « problemset 

». Au lieu de définir tout d’un seul coup, on peut commencer par un fichier 

DTD qui ne définit que l’élément « choice » : 

 

 

 

Pour les fins de notre exemple, supposons que ce dernier fichier porte le nom de 

« choice.dtd » et se trouve à l’adresse « http://www.mondomaine.com/choice.dtd ». 

On pourra alors en importer le contenu dans un autre fichier externe avec une « entité 

paramètre externe ». À la différence d’une entité paramètre usuelle, une entité paramètre 

externe pointe vers un autre document que le logiciel devra traiter. On définit 

l’entité paramètre externe avec l’instruction « SYSTEM » suivie d’une adresse web 

comme dans cet exemple : 

 

Pour inclure le contenu du fichier externe (« choice.dtd » dans notre exemple), il suffit 

tout simplement de faire appel à l’entité comme ceci : 

 

%monentite; 

Dans ce cas, tout se déroule comme si le contenu du fichier « choice.dtd » était inséré à 

l’endroit où se trouve l’appel (« %monentite; »). On peut définir l’élément « problemset 

» à l’aide du fichier DTD suivant : 

CC BY-NC-SA


 

%monentite; 

 

 

 

 

 

 

 

On peut obtenir le même résultat avec Relax NG, un peu plus simplement avec l’utilisation 

de l’instruction « include ». Créons d’abord un fichier « choice.rnc » avec le 

contenu suivant : 

choiceele = element choice { 

element response { text}, 

element feedback {text} 

} 

On peut alors réutiliser le motif « choiceele » dans n’importe quel autre fichier Relax 

NG comme le montre cet exemple : 

include "choice.rnc" 

element problemset { 

( 

element title { text } , 

element recall { 

( text 

| element section {text} 

| element codexml {text}) * 

} , 

element item { 

element question {text}, 

choiceele+ 

} * 

)* 

} 

En bref, il est facile de diviser des spécifications Relax NG ou DTD en plusieurs fichiers 

plus petits, plus faciles à éditer, et qui peuvent être plus facilement réutilisés. 

CC BY-NC-SA


1.6.15 Définir l’élément-racine 

Avec une DTD, il n’est pas possible de définir l’élément-racine. Celui-ci est déclaré 

par l’instruction DOCTYPE qui se trouve dans le document XML. Avec Relax NG, 

on peut non seulement spécifier l’élément-racine avec le mot-clef start, mais on peut 

aussi permettre une certaine flexibilité. Par exemple, l’instruction « start = problemset 

| choice » placée dans un fichier Relax NG, nous indique qu’on peut utilisé l’élément 

problemset ou l’élément choice comme élément-racine. 

1.6.16 Définir le type de contenu en Relax NG 

Dans tous nos exemples de Relax NG, nous n’avons prévu que du contenu textuel (text) 

ou des éléments vides (empty). Relax NG permet de spécifier le contenu d’un élément 

ou d’un attribut d’une manière très fine. Il emprunte ici la spécification mise au point 

par XML Schema. En particulier, on peut spécifier un contenu textuel à l’aide d’une 

expression régulière. Voici quelques exemples. 

Type Explication Exemple 

xsd:date 

xsd:dateTime 

xsd:string pattern = 

"[ˆ:]+" 


".+/.+" 


".+@.+" 

Une date formattée avec 

la convention YYYY- 

MM-DD 

Un moment spécifique à 

la seconde près 

Une chaîne de caractères 

contenant au moins un 

caractère, à l’exclusion 

du symbole : 

Deux chaînes de caractères 

séparée par un caractère 

/ 

Deux chaînes de caractères 

séparée par un caractère 

@ 

2001-01-01 ou 1999-12- 

30 

2000-12-31T03:32:00 

maison 

01/01 

lala@to.com 

"text" | "html" text ou html text 

xsd:string min- Une chaîne caractères faisant 

monmotdepasse 

Length="7" max- 

entre 7 et 25 carac- 

Length="25" 

tères 

xsd:decimal minExclusive="0.0" 

Un nombre entre 0 et 10 5 

maxInclu- 

sive="10.0" 

xsd:decimal fractionDigits="3" 

Un nombre n’ayant pas 5.001 

plus de 3 chiffres après la 

virgule (le point) 

CC BY-NC-SA


On déclare ensuite le contenu d’un élément ou d’un attribut comme ceci : element 

madate xsd:date. 

1.6.17 Est-ce qu’il existe un outil pour passer d’un format à l’autre 

(DTD, Relax NG, XML Schema) 

Oui, le programme Java Trang (http://www.thaiopensource.com/relaxng/trang.html) 

permet de passer facilement d’un format à l’autre. 

1.6.18 Est-ce qu’un document DTD est un document XML 

Absolument pas. Par contre, une DTD est un document textuel. Les fichiers 

XML Schema sont par contre toujours en XML, alors que les fichiers Relax NG sont 

parfois en XML, parfois en simple format textuel comme dans nos exemples. 

1.6.19 Pourquoi est-ce qu’il n’est pas suffisant d’utiliser des documents 

bien formés À quoi sert la validation 

Les documents XML sont faits pour être échangés et assurer la pérennité des informations. 

Si plusieurs individus ou plusieurs institutions s’entendent sur une DTD commune, 

il sera beaucoup plus facile d’échanger de l’information. 

1.6.20 Est-ce vraiment nécessaire d’avoir des documents valables 

Est-ce que je dois vraiment toujours travailler avec des fichiers 

DTD, XML Schema ou Relax NG 

En pratique, la validation n’est pas essentielle et une application logicielle ne devrait 

pas exiger des documents valables. Si vous concevez une application, la règle implicite 

est que toute balise ou attribut non prévue devrait être ignorée. Un navigateur qui sait 

lire et afficher du XML devrait pouvoir lire tout XML bien formé, même s’il n’est pas 

valable. Si vous inventez une nouvelle balise XHTML, le navigateur devrait tout simplement 

ne pas en tenir compte. Les concepteurs du XML n’ont pas inscrit la nécessité 

d’être valable à même la définition du XML et c’est un choix qui n’a jamais été remis 

en question par l’organisme de normalisation W3C. 

Il arrive, par exemple, qu’il soit inutilement complexe d’exiger que les documents 

soient bien formés. Si on se contraint à des documents bien formés, on peut même 

en arriver à des solutions qui sont techniquement inférieures. Pour quelques exemples, 

voir l’article (en anglais) « Must Ignore vs. Microformats » d’Elliotte Rusty Harold à 

l’adresse http://cafe.elharo.com/xml/must-ignore-vs-microformats/. 

Consultez le pense-bête DTD pour avoir une vue d’ensemble et pour réviser. 

CC BY-NC-SA


1.6.21 Livres de référence 

– Eric van der Vlist, Relax NG, O’Reilly Media, 2003, 486 pages. 

– Priscilla Walmsley, Definitive XML Schema, Prentice Hall Trade, 2001. 


1. Combien de DTD peut avoir un document XML Choisissez la bonne réponse 


(a) Une seule. 

(b) Autant qu’on veut. 

2. Il est nécessaire d’avoir une définition de type de document, par exemple un 

document DTD, pour déterminer si un document XML est valable. Choisissez la 


(a) Vrai. 

(b) Faux. 

3. Qu’est-ce qu’une DTD interne Choisissez la bonne réponse parmi les choix 

suivants. 

(a) Une DTD qui a été conçue à l’interne, dans une compagnie ou institution. 

(b) Une DTD qui apparaît dans le document XML entre des crochets. 

4. Quel symbole est utilisé dans les DTD pour signifier qu’un élément est optionnel, 

c’est-à-dire qu’on peut en trouver un ou aucun Choisissez la bonne réponse 


(a) 

(b) * 

(c) + 

(d) | 

5. Quel symbole est utilisé dans les DTD pour signifier qu’un élément peut ne pas 

apparaître, n’apparaître qu’une fois ou apparaître plusieurs fois Choisissez la 


(a) 

(b) * 

(c) + 

(d) | 

6. Quel symbole est utilisé dans les DTD pour signifier qu’un élément doit apparaître 

au moins une fois Choisissez la bonne réponse parmi les choix suivants. 

CC BY-NC-SA


(a) 

(b) * 

(c) + 

(d) | 

7. Quel symbole est utilisé dans les DTD pour signifier qu’un élément ou un autre 

peut apparaître Choisissez la bonne réponse parmi les choix suivants. 

(a) 

(b) * 

(c) + 

(d) | 

8. Combien d’éléments « nom » peut contenir un document XML qui débute ainsi : 

 

 

 

 

 

]> 


(a) Au moins un. 

(b) 1 

(c) 2 

(d) 3 

(e) 3 ou plus 

9. Soit le document DTD suivant, disponible à l’adresse 

« http://www.mondomain.com/madtd.dtd ». Dites quels documents XML 

sont valables. 

 

 

 

 


CC BY-NC-SA


(a) 

 

 

 

 

(b) 

 

 

Jean B Pearson 

12 

Introduction aux ordinateurs 

 

(c) 

 

 

Jean Pearson 

12 


 

(d) 

 

Jean Pearson 

(e) 

 

 

Réjean Bougon 

3156 

Introduction à l’arithmétique 


 

(f) 

 

 


Réjean Bougon 

CC BY-NC-SA


3156 

 




 

 

 

 


(a) 

 

 

 

Jean Pearson 

12 


Introduction à l’informatique 

 

(b) 

 

 

 

 

(c) 

 

 

Jean Pearson 

12 


 




CC BY-NC-SA


 

 

 

 

 

 


(a) 

 

 

 

Palado 

Pierre 

 

 

Côté 

Yvon 

 

 

(b) 

 

 

 

Pierre 

Palado 

 

 

Yvon 

Côté 

 

 

(c) 

 

 

 

Pierre 

Palado 

 

CC BY-NC-SA


 

Yvon 

Côté 

 

 

(d) 

 

 

 

Pierre 

Palado 

 

 

Jean 

Bertran 

 

 

Luc 

Fauche 

 

 

Yvon 

Côté 

 

 

(e) 

 

 

 

Pierre 

Palado 

 

 

Yvon 

Côté 

 

 

Jean 

Bertran 

 

 

CC BY-NC-SA


Luc 

Fauche 

 

 




 

 

 

 

 

 


(a) 

 

 

 

Palado 

Pierre 

432432432 

 

 

(b) 

 

 

 

Palado 

Pierre 

Services récréatifs 

432432432 

 

 

(c) 

 

CC BY-NC-SA


 

 

Palado 

Pierre 


 

 

(d) 

 

 

 

Palado 

Pierre 

432-432-432444 

433-444-444444 


 

 




 

 

 

 

 

 


(a) 

 

 

 

 

 

]> 

CC BY-NC-SA


 

 

Palado 

Pierre 

 

 

Côté 

Yvon 

 

 

(b) 

 

]> 

 

 

50$ 

 

 

Yvon 

Côté 

 

 

(c) 

 

 

 

Yvon 

Côté 

 

 

Yvon 

Côté 

 

 

50$ 

 

 

CC BY-NC-SA


14. Dites quels documents XML sont valables. Choisissez toutes les réponses qui 


(a) 

 

 

 

]> 

 

Jeu de la chandelle 

15-25 ans 

jeune adulte 

 

(b) 

 

 

 

]> 

 


15-25 ans 

 

(c) 

 

 

 

]> 

 

Jeu de la poudre 

25-35 ans 

universitaire 

 

CC BY-NC-SA


(d) 

 

 

 

]> 

 


J’ai maintenant la balise age... 

25-35 ans 

suivie d’une balise niveau 

universitaire 

et je peux continuer 

 

(e) 

 

 

 

]> 

 

Ceci est du XML avec contenu mixte 


J’ai maintenant la balise age... 

25-35 ans 

suivie d’une balise niveau 

universitaire 

et je peux continuer 

 



(a) 

 

 

 

CC BY-NC-SA


 

 

 

]> 

 

 


15-25 ans 

jeune adulte 

 

 

(b) 

 

 

 

 

 

 

]> 

 

 


 

15-25 ans 

 

 

 

 

 

(c) 

 

 

 

 

 

 

]> 

CC BY-NC-SA


 

 


 

15-25 ans 

 

jeune adulte 

 

 

 

 

(d) 

 

 

 

 

 

 

]> 

 

 


15-25 ans 

 

J’ajoute une balise Mon nom est Bond 

 

(e) 

 

 

 

 

 

 

]> 

 

 


CC BY-NC-SA


15-25 ans 

 

je peux tout me permettre 

 



(a) 

 

 

 

 

]> 

 

 

Jean 

 

 

Martin 

 

10$ 

 

(b) 

 

 

 

 

 

]> 

 

 

Jean 

 

 

Martin 

 

10$ 

 

CC BY-NC-SA


(c) 

 

 

 

 

 

 

 

]> 

 

 

Jean 

 

 

Martin 

 

10$ 

 

(d) 

 

 

 

 

 

 

 

]> 

 

 

Jean 

 

 

Martin 

 

10$ 

 

CC BY-NC-SA


(e) 

 

 

 

 

 

 

 

]> 

 

 

Jean 

 

 

Martin 

 

10$ 

 

(f) 

 

 

 

 

 

 

 

 

]> 

 

 

 

Jean 

 

 

CC BY-NC-SA


Martin 

 

10$ 

 

 

 

Jean 

 

 

Martin 

 

10$ 

 

 

(g) 

 

 

 

 

 

 

 

 

]> 

 

 

 

Jean 

 

 

Martin 

 

10$ 

 

 

 

Jean 

 

CC BY-NC-SA


 

Martin 

 

10$ 

 

 

(h) 

 

 

 

 

 

 

 

 

]> 

 

 

 

Jean 

 

 

Martin 

 

10$ 

 

 

 

Jean 

 

 

Martin 

 

10$ 

 

 

CC BY-NC-SA


17. Dans une DTD, que signifie la ligne suivante 

 

Indice. Il s’agit d’une valeur d’attribut par défaut. 


(a) Que les éléments « etudiant » doivent toujours avoir explicitement un attribut 

« universite » ayant comme valeur « Université du Québec à Montréal ». 

(b) Que les éléments « etudiant » ont toujours implicitement un attribut « universite 

» ayant comme valeur « Université du Québec à Montréal ». 

(c) Que les éléments « etudiant » ont implicitement un attribut « universite » 

ayant comme valeur « Université du Québec à Montréal », à moins que l’on 

fournisse une autre valeur de type CDATA. 

(d) Que les éléments « etudiant » ont implicitement un attribut « universite » 

ayant comme valeur « Université du Québec à Montréal » et que si l’on 

fournit explicitement l’attribut, il doit avoir comme valeur « Université du 

Québec à Montréal ». 

18. Dans une DTD, que signifie la ligne suivante 

 

Indice. Il s’agit d’une valeur d’attribut par défaut. 


(a) Que les éléments « etudiant » doivent toujours avoir explicitement un attribut 

« universite » ayant comme valeur « Université du Québec à Montréal ». 

(b) Que les éléments « etudiant » ont toujours implicitement un attribut « universite 

» ayant comme valeur « Université du Québec à Montréal ». 

(c) Que les éléments « etudiant » ont implicitement un attribut « universite » 

ayant comme valeur « Université du Québec à Montréal », à moins que l’on 

fournisse une autre valeur de type CDATA. 

(d) Que les éléments « etudiant » ont implicitement un attribut « universite » 

ayant comme valeur « Université du Québec à Montréal », et que si l’on 

fournit explicitement l’attribut, il doit avoir comme valeur « Université du 

Québec à Montréal ». 

19. Dans une DTD, qu’est-ce qui décrit le mieux la ligne suivante 

CC BY-NC-SA


 


(a) Partout où le texte « universite » apparaît dans le document XML (mais pas 

dans la DTD), il est remplacé par « Université du Québec à Montréal ». 

(b) Partout où le texte « &universite; » apparaît dans le document XML (mais 

pas dans la DTD), il est remplacé par « Université du Québec à Montréal ». 

(c) Partout où le texte « &universite; » apparaît dans le document XML (mais 

pas dans la DTD et dans les valeurs par défaut des attributs), il est remplacé 

par « Université du Québec à Montréal ». 

20. Dans un document XML, que signifie la ligne suivante 

 

si le document XML commence par 

 

 

Indice. Il s’agit d’une entité paramètre. 


(a) Partout dans le document XML où le texte « &administration; » apparaît, 

il est remplacé par « president,comptable,adjoint ». 

(b) Partout dans la DTD externe, le texte « %administration; » est remplacé par 

« president,comptable,adjoint ». 

(c) Partout dans la DTD externe, à supposer qu’elle ne définisse pas déjà l’entité 

« administration », le texte « %administration; » est remplacé par « president,comptable,adjoint 

». 

21. Choisissez les documents valables. Choisissez toutes les réponses qui s’appliquent. 

(a) 

 

 

 

 

CC BY-NC-SA


 

]> 

 

La mère souffre de la grippe. 

Le père est en santé. 

L’enfant de 

et de se porte bien. 

 

(b) 

 

 

 

 

 

]> 

 



L’enfant de et 

de se porte bien. 

 

(c) 

 

 

 

 

 

]> 

 



L’enfant de 

et de se porte bien. 

 

22. Trouvez le terme qui se distingue. 

CC BY-NC-SA



(a) XML Schema 

(b) Relax NG 

(c) DTD 

(d) Schematron 

(e) XML 

(f) Examplotron 

23. Je dois définir des entités, quelle technologie est-ce que je dois utiliser 


(a) XML Schema 

(b) Relax NG 

(c) DTD 

24. Quelle est la signification de DTD Choisissez la bonne réponse parmi les choix 

suivants. 

(a) Document Type Definition 

(b) Document Type Declaration 

(c) Dynamic Type Definition 

25. Choisissez la meilleure réponse Choisissez la bonne réponse parmi les choix 

suivants. 

(a) La spécification DTD fait partie intégrante du XML. 

(b) Le nom des éléments doit être en minuscule. 

(c) Tous les documents doivent avoir une DTD. 

26. Choisissez la meilleure réponse Choisissez la bonne réponse parmi les choix 

suivants. 

(a) Toutes ces réponses sont vraies 

(b) Le XML est sensible à la casse des cararactères 

(c) Tous les documents XML doivent avoir un élément-racine. 


1. (a) (Bonne réponse) Par contre, il peut y avoir une partie interne à la DTD, 

c’est-à-dire une partie qui est écrite dans le document XML lui-même. Le 

tout (DTD externe et interne) forme une seule DTD. 

(b) Non. 

2. (a) (Bonne réponse) Un document est dit valable s’il est bien formé et respecte 

sa DTD. 

CC BY-NC-SA


(b) On peut seulement vérifier qu’il est bien formé. 

3. (a) Incorrect. La provenance de la DTD est sans conséquence. 

(b) (Bonne réponse) Correct. 

4. (a) (Bonne réponse) Oui. 

(b) Non. 

(c) Non. 

(d) Non. 

5. (a) Non. 

(b) (Bonne réponse) Oui. 

(c) Non. 

(d) Non. 

6. (a) Non. 

(b) Non. 

(c) (Bonne réponse) Oui. 

(d) Non. 

7. (a) Non. 

(b) Non. 

(c) Non. 

(d) (Bonne réponse) Oui. 

8. (a) Non. 

(b) Non. 

(c) (Bonne réponse) Effectivement. La déclaration de type de document nous 

indique que l’élément-racine est « cheque » et que l’élement « cheque » 

doit contenir exactement un élément « recipiendaire » et un élément « emetteur 

», chacun contenant exactement un élément « nom ». 

(d) Non. 

(e) Non. 

9. (a) (Bonne réponse) Oui. Ce document est valable, car l’astérisque (*) permet 

d’avoir zéro ou plusieurs balises « cours ». 

(b) Non, la balise ne peut contenir que du texte et aucune balise. 

(c) Non, la déclaration de type de document indique que la racine doit être une 

balise de type « nom ». 

(d) (Bonne réponse) Oui. On utilise bien l’élément « nom » comme élémentracine 

et il est défini dans la DTD. 

(e) (Bonne réponse) Oui. L’astérisque permet d’avoir plusieurs éléments 

« cours ». 

(f) Non. Il faut que les éléments apparaissent dans l’ordre : nom, numero et 

cours. 

CC BY-NC-SA


10. (a) Non. La déclaration XML doit apparaître en premier dans un document 

XML. 

(b) Non. Le document n’est pas valable parce que le symbole « + » implique 

que l’élément « cours » doit apparaître au moins une fois. 

(c) (Bonne réponse) Oui. L’élément « cours » apparaît une fois, comme cela 

est exigé. 

11. (a) Non. Selon la DTD, il faut que les noms apparaissent après les prénoms. 

(b) (Bonne réponse) Oui. La compagnie a un comptable et un président, 

comme cela est demandé. 

(c) Non. Il faut au moins un comptable. 

(d) (Bonne réponse) Oui. On peut avoir plus d’un ingénieur. 

(e) Non. Les ingénieurs doivent apparaître avant les comptables. 

12. (a) Non. L’élément employé doit contenir au moins un élément « division ». 

(b) Non. L’élément employé doit contenir un élément « division », mais après 

l’élément « telephone ». 

(c) (Bonne réponse) Oui. L’élément « telephone est facultatif ». 

(d) Non. L’élément « telephone » peut ne pas apparaître ou apparaître une fois. 

13. (a) (Bonne réponse) Dans ce cas précis, la DTD à l’adresse 

« http://www.mondomain.com/madtd.dtd » n’est jamais utilisé. Il ne 

faut donc considérer que la DTD interne. Selon cette DTD, le document 

XML est valable. 

(b) (Bonne réponse) Pour traiter le document, il faut ici combiner les deux 

DTD; on voit que l’élément « taxe » utilise un élément « comptable » de la 

DTD externe. Cela est parfaitement valable. 

(c) Il n’est pas prévu dans la DTD externe que l’élément « compagnie » 

contienne un élément « montant », donc ce n’est pas permis. La DTD interne 

vient s’ajouter à la DTD externe, mais sans plus. 

14. (a) Non. La DTD interne stipule que l’élément « jeu » contient un élément 

« nom », suivi d’un élément « age » ou d’un élément « niveau », mais pas 

les deux. 

(b) (Bonne réponse) Oui. La DTD interne stipule que l’élément « jeu » contient 

un élément « nom », suivi d’un élément « age » ou d’un élément « niveau », 

mais pas les deux. 

(c) (Bonne réponse) Oui. La DTD interne stipule que l’élément « jeu » contient 

un élément « nom » qui peut ou non être suivi de plusieurs éléments « age » 

ou éléments « niveau ». 

(d) (Bonne réponse) Oui. La DTD interne stipule que l’élément « jeu » contient 

un élément « nom », suivi de contenu mixte avec texte et choix de balises 

entre « age » et « niveau ». 

(e) Non. L’élément « jeu » doit commencer par une balise « nom ». 

CC BY-NC-SA


15. (a) Le problème ici est qu’on peut avoir un élément « age » ou un élément 

« niveau », mais pas les deux. L’élément « activite » peut contenir tout 

élément déclaré dont « jeu ». L’élément « jeu » a une balise optionnelle 

« gratuit », qui est ici absente. 

(b) Non. L’élément « gratuit » doit être vide de tout, incluant les espaces et 

retours de chariot. Il faut donc utiliser la syntaxe ou, 

plus simplement, . 

(c) On utilise les éléments « age » et « niveau », alors qu’on doit choisir entre 

l’un ou l’autre, à cause de l’opérateur « | » (ou logique). 

(d) (Bonne réponse) Oui. L’élément « activite » peut contenir n’importe quel 

élément déclaré et du contenu mixte. 

(e) Non. L’élément « peuimporte » n’est pas prévu par la DTD; il n’est donc 

pas permis. 

16. (a) Non. Il n’est pas permis d’avoir un attribut non déclaré dans la DTD. 

(b) (Bonne réponse) Oui. L’élément « cheque » a bien un attribut « commentaire 

», comme cela est nécessaire. 

(c) Non. L’élément « emetteur » devrait avoir un attribut « commentaire ». 

(d) (Bonne réponse) Oui. L’élément « emetteur » n’a pas d’attribut « commentaire 

», mais c’est permis à cause de la mention « IMPLIED ». 

(e) Non. L’attribut « numero="1324" » doit avoir comme valeur un nom XML; 

en d’autres termes, il ne peut commencer par un chiffre. 

(f) Non. Nous avons ici deux attributs avec une valeur de type ID : il faut qu’ils 

aient des valeurs différentes. En XML, la valeur d’un attribut de type ID 

identifie un élément unique. 

(g) (Bonne réponse) Oui. Observez que tous les attributs ayant des valeurs de 

type ID ont des valeurs distinctes. 

(h) (Bonne réponse) Oui. Observez encore une fois que tous les attributs ayant 

des valeurs de type ID ont des valeurs distinctes. 

17. (a) Non. 

(b) Non. 


(d) Non. 

18. (a) Non. La valeur peut aussi être implicite. 

(b) C’est vrai, mais on peut aussi stipuler explicitement la valeur. 

(c) Non. La valeur de l’attribut est fixe. 

(d) (Bonne réponse) Oui. 

19. (a) Non. 

(b) C’est juste, mais légèrement incomplet. 


CC BY-NC-SA

La validation des documents XML 91 

20. (a) Non. Ce serait toutefois le cas si nous avions la ligne 

 


(c) Non. La partie interne de la DTD a préséance sur la DTD externe. 

21. (a) La valeur d’un attribut de type « ID » ou « IDREF » doit être un nom XML 

valable, donc elle ne doit pas débuter par un chiffre. 

(b) Non. Toutes les valeurs d’attribut de type « IDREF » ne correspondent pas 

à une valeur d’attribut de type « ID ». 

(c) (Bonne réponse) Effectivement. Tous les valeurs d’attribut de type 

« IDREF » correspondent à une valeur d’attribut de type « ID ». 

22. (a) Non. XML Schema est une technologie permettant de valider du XML. 

(b) Non. Relax NG est une technologie permettant de valider du XML. 

(c) Non. DTD est une technologie permettant de valider du XML. 

(d) Non. Schematron est une technologie permettant de valider du XML. 

(e) (Bonne réponse) Non. Le XML n’est pas une technologie de validation. 

(f) Non. Examplotron est une technologie permettant de valider du XML. 

23. (a) Non. XML Schema ne permet pas de définir des entités. 

(b) Non. Relax NG ne permet pas de définir des entités. 

(c) (Bonne réponse) Effectivement. DTD permet la définition des entités. 


(b) Non. 

(c) Non. 


(b) Non. 

(c) Non. 


(b) Oui, mais ce n’est pas tout. 

(c) Oui, mais ce n’est pas tout. 

1.7 La validation des documents XML 


Valider des documents XML. 

CC BY-NC-SA


1.7.2 Activité de validation 

On peut facilement vérifier si un document XML est « bien formé ». Il suffit de lui 

donner l’extension « .xml » (ou « .xhtml ») et de l’ouvrir dans Mozilla Firefox, par 

exemple. Pour effectuer une telle vérification, il existe aussi des services en ligne, dont 

celui de la Brown University. 

Cependant, il arrive qu’on veuille vérifier que le document est non seulement bien 

formé, mais aussi valable par rapport à des documents DTD locaux. Apprenons donc à 

valider des documents XML, en exécutant les directives qui suivent, car cela vous sera 

très utile dans vos travaux en XML. 

La procédure que nous proposons suppose que vous connaissez bien les éléments de 

base d’un système d’exploitation, comme l’utilisation de la ligne de commande et 

l’exécution de programmes. Nous ne donnons la procédure que pour Windows, mais 

elle est très similaire sous MacOS ou Linux. 

Procédure pour valider des documents XML 

Avant de procéder à la validation, préparons notre environnement. Allez dans un répertoire, 

par exemple « C:\XML », et créez le fichier « monfichier.dtd » avec le contenu 

suivant, en utilisant le bloc-notes : 

 

 

 

Puis, créez un document appelé « mauvais.xml » avec le contenu suivant, toujours à 

l’aide du bloc-notes : 

 

 

12 

Il est important que les deux fichiers soient dans le même répertoire. En effet, la ligne 

dans le fichier « mauvais.xml » 

indique qu’il devrait y avoir un fichier « monfichier.dtd » dans le même répertoire. 

Vérifions maintenant si le fichier « mauvais.xml » est valable. 

1. D’abord, vous devez disposer d’une machine virtuelle Java récente (Java 1.4 ou 

mieux) sur votre ordinateur, incluant le compilateur Java : « javac ». Si vous 

n’en avez pas, il faut effectuer un téléchargement et une installation d’une telle 

machine. En outre, vous devez avoir sur votre ordinateur le SDK, pas uniquement 

le JRE. Sur la page qui se trouve à l’adresse http://java.sun.com/j2se/1.4.2/ 

download.html, cliquez sur « Download J2SE SDK ». Le téléchargement peut 

prendre plusieurs minutes. Il suffit ensuite de lancer le fichier exécutable que 

CC BY-NC-SA


vous venez d’enregistrer sur votre ordinateur pour installer le SDK. Une fois le 

SDK installé, vous pouvez poursuivre l’activité de vérification. 

2. Placez le fichier Validateur.java dans le répertoire où se trouvent déjà vos fichiers 

« mauvais.xml » et « monfichier.dtd », soit dans « C:\XML ». Votre fichier « Validateur.java 

» devrait avoir le contenu suivant : 

//fichier Validateur.java 

import java.io.*; 

import org.xml.sax.*; 

import org.xml.sax.helpers.*; 

import javax.xml.parsers.*; 

/** 

* Ce programme est inspiré de Xerces-J. Il a été modifié 

* par Daniel Lemire pour le cours "Gestion de l’information 

* avec XML". 

* 

* Date de la première modification: 5 novembre 2004. 

* 

* Il suffit de compiler le programme avec 

* "javac Validateur.java". 

* On peut ensuite valider un document en faisant 

* "java Validateur monfichier.xml". 

* 

*/ 

public class Validateur extends DefaultHandler { 

public Validateur() { 

} 

public void warning(SAXParseException ex) 

throws SAXException { 

printError("Avertissement", ex); 

} 

public void error(SAXParseException ex) 


printError("Erreur", ex); 

} 

public void fatalError(SAXParseException ex) 


printError("Erreur fatale", ex); 

} 

protected void printError(String type, SAXParseException ex) { 

System.err.print("["); 

CC BY-NC-SA


} 

System.err.print(type); 

System.err.print("] "); 

if (ex== null) { 

System.out.println("!!!"); 

} 

String systemId = ex.getSystemId(); 

if (systemId != null) { 

int index = systemId.lastIndexOf(’/’); 

if (index != -1) 

systemId = systemId.substring(index + 1); 

System.err.print(systemId); 

} 

System.err.print(" ligne: "); 

System.err.println(ex.getLineNumber()); 

System.err.println(", colonne: "); 

System.err.print(ex.getColumnNumber()); 

System.err.print(", description: "); 

System.err.print(ex.getMessage()); 

System.err.println(); 

System.err.flush(); 

} 

public static void main(String argv[]) 

throws org.xml.sax.SAXException, 

javax.xml.parsers.ParserConfigurationException { 

Validateur counter = new Validateur(); 

PrintWriter out = new PrintWriter(System.out); 

XMLReader parser = null; 

parser = SAXParserFactory.newInstance().newSAXParser(). 

getXMLReader(); 

parser.setContentHandler(counter); 

parser.setErrorHandler(counter); 

parser.setFeature("http://xml.org/sax/features/validation", 

true); 

parser.setFeature("http://xml.org/sax/features/namespaces", 

true); 

try { 

parser.parse(argv[0]); 

} catch (SAXParseException e) { 

} catch (Exception e) { 

System.err.println("erreur: Erreur de traitement -" 

+e.getMessage()); 

} 

} 

CC BY-NC-SA


3. Ensuite, lancez la machine virtuelle Java avec une ligne de commande. Pour 

cela, il faut ouvrir une fenêtre de commande. Sous Windows XP, dans le menu 

« Démarrer », cliquez sur « Exécuter »; une fenêtre s’ouvre, tapez le nom de 

programme « cmd » pour ouvrir une fenêtre de commande. Notez qu’avec les 

versions plus anciennes de Windows, comme Windows 98, il faut taper « command.com 

». Une fenêtre s’ouvre alors avec un fond noir, c’est la fenêtre de 

commande. Vous allez pouvoir y taper des lignes de commande pour vérifier si 

votre document XML est valable. Les commandes de base sont : « dir » (affiche 

le contenu d’un répertoire), « cd » (change de répertoire), « cd .. » (répertoire parent), 

« mkdir » (création d’un nouveau répertoire), « copy » (copie d’un fichier), 

« move » (déplacement d’un fichier), et « del » (supprime un fichier). 

4. Testez l’installation de votre machine virtuelle en tapant « java » suivi du retour 

de chariot. Vous devriez recevoir un message qui commence par : 

Usage: java [-options] class [args...] 

(to execute a class) 

or 

java -jar [-options] jarfile [args...] 

(to execute a jar file) 

ou quelque chose de similaire. Testez aussi l’installation du compilateur en tapant 

« javac »; vous devriez voir un message qui commence par quelque chose 

comme : 

Usage: javac 

Si ce n’est pas le cas, nous vous conseillons de vérifier l’installation de votre 

machine virtuelle et de procéder à sa réinstallation au besoin. Si tout est bien 

installé et que ça ne fonctionne toujours pas, vous devrez indiquer le chemin 

pour trouver le compilateur en tapant la ligne de commande 

PATH=adresse_du_fichier_javac.exe 

Le fichier « javac.exe » se trouve dans le dossier « bin » du dossier où vous 

avez installé le SDK. Par défaut, ce fichier se trouve dans le « C: ». L’adresse 

du répertoire contenant le fichier « javac.exe » est donc « C:\j2sdk1.4.2_06\bin » 

ou « C:\Program Files\Java\jdk1.5.0\bin ». Si vous ne savez plus où est installé 

le SDK, vous pouvez faire une recherche, à partir du menu « Démarrer » de 

Windows. Une fois le chemin indiqué, retapez la commande « javac » et cette 

fois, tout devrait fonctionner. Comme il peut être lourd de modifier la variable 

d’environnement PATH chaque fois, il est possible de la modifier une fois pour 

toute : allez dans « Démarrer », choisissez « Paramètres », puis « Panneau de 

configuration », et ouvrez « Système », cliquez sur l’onglet « Avancé »; cliquez 

ensuite sur le bouton « Variables d’environnement », sélectionnez « PATH » 

dans la liste des variables, cliquez sur le bouton « Modifier » et ajoutez, à la 

fin du contenu de la variable, « ;adresse_du_fichier_javac.exe », par exemple 

« ;C:\Program Files\Java\jdk1.5.0\bin ». 

5. Ensuite, placez-vous dans le dossier où se trouvent votre fichier XML et sa DTD. 

Vous savez toujours où vous vous trouvez dans l’arborescence de votre ordinateur, 

puisque chaque ligne de commande commence par l’adresse où vous êtes. 

CC BY-NC-SA


La commande pour se déplacer est « cd adresse ». Par exemple, si la ligne commence 

par « C:\Documents and Settings\lucie> », vous êtes dans le dossier de 

lucie. Pour aller au dossier XML qui se trouve sur le disque C, il faut taper : 

« cd C:\XML », puis faire le retour de chariot. Une nouvelle ligne apparaît et 

commence par : « C:\XML> ». Maintenant que vous êtes dans le dossier où se 

trouve votre fichier XML, vous pouvez vérifier s’il est valable. 

6. Faites « javac Validateur.java » pour compiler le petit programme qui pourra vous 

servir à vérifier la validité des documents XML. Vous ne devriez pas avoir de mal 

avec la compilation. Par exemple, vous pourriez voir à l’écran : 

C:\XML>javac Validateur.java 

Note: Validateur.java uses or overrides a deprecated API. 

Note: Recompile with -deprecation for details. 

Vous pouvez ignorer les avertissements vous incitant à utiliser l’option « - 

deprecation ». 

7. Tapez la ligne de commande « java Validateur mauvais.xml », puis faites un 

retour de chariot. Il est important de respecter la casse dans les lignes de commande. 

Si rien de significatif ne s’affiche, votre fichier est valable, sinon, une description 

des erreurs s’affichera (en anglais). Si la machine virtuelle quitte avec 

l’erreur « java.lang.NoClassDefFoundError » alors que vous êtes bien dans le 

bon répertoire, faites alors « java -cp . Validateur mauvais.xml ». 

8. Pour quitter, vous n’avez qu’à fermer la fenêtre de commande. 

Vérification de la procédure 

Après avoir tapé la commande « java Validateur mauvais.xml » pour vérifier si le fichier 

« mauvais.xml » est valable, vous devriez obtenir le message d’erreur suivant indiquant 

qu’il manque un élément « numero » (le message exact peut varier et il pourrait être en 

français) : 

> java Validateur mauvais.xml 

[Error] mauvais.xml:3:-1: Element "etudiant" does not allow "age" here. 

[Error] mauvais.xml:3:-1: Element "etudiant" requires additional elements. 

Pour vous assurer de bien comprendre, reprenez la procédure; créez un autre document 

appelé « bon.xml » avec le contenu suivant : 

 

 

112 

Cette fois-ci, vous devriez, en vérifiant que le document est valable, obtenir le message 

suivant : 

> java Validateur bon.xml 

CC BY-NC-SA

Espaces de noms 97 

1.7.3 Retour 

Est-ce que vous avez pu vérifier si les fichiers « mauvais.xml » et « bon.xml » étaient 

valables Si oui, passez aux autres activités, sinon contactez la personne tutrice ou 

cherchez encore un peu. 

1.8 Espaces de noms 


Utiliser les espaces de noms 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation. Ce texte traite 

des espaces de noms auxquels il faut faire appel quand on utilise plusieurs « vocabulaires 

» XML, en même temps. 

1.8.3 Les vocabulaires XML 

Un « vocabulaire XML » est un ensemble de noms de balises et d’attributs ayant une 

signification donnée. Par exemple, les gens de la comptabilité au sein d’une entreprise 

pourraient avoir un vocabulaire XML pour décrire certaines transactions, alors que 

les ingénieurs pourraient avoir leur propre vocabulaire pour décrire certains processus 

techniques. Les deux équipes pourraient utiliser les mêmes noms d’élément, comme 

« échéance », mais avec des significations différentes. On dira alors que nous avons 

deux vocabulaires XML. 

Voyons un autre exemple. Imaginez que votre institution ait un vocabulaire XML pour 

les expéditions de marchandise et un vocabulaire XML pour la rédaction des factures. 

Un document XML combinant à la fois de l’information concernant une expédition et 

une facture devra utiliser deux vocabulaires. 

Un vocabulaire XML peut être associé à un document DTD; il peut aussi être associé 

à un espace de noms. 

1.8.4 Les identificateurs de ressources uniformes (URI) 

Un identificateur de ressources uniformes (Uniform Resource Identifier ou URI) est 

une adresse Internet composée d’un nom de protocole ou « schéma », comme file, http, 

ftp, news, mailto, gopher, urn, suivi d’un deux-points « : », lui-même suivi d’un chemin, 

comme « www.mondomain.com/fichier ». Un URI ne pointe pas nécessairement vers 

CC BY-NC-SA


un fichier, mais peut très bien être une adresse purement fictive ou une adresse pointant 

vers une application logicielle sur un serveur. 

Par exemple, « http://www.mondomain.com/fichier » et 

« mailto:billg@microsoft.com » sont des URI. Les URI ne doivent pas contenir 

d’accents, et la casse est significative sauf pour ce qui est du nom du protocole 

(HTTP versus http) et du nom de domaine (xerox.com versus XEROX.COM). Nous 

reviendrons sur les URI dans le module 5. 

1.8.5 Les espaces de noms 

Un espace de noms est identifié par un URI; il y a correspondance unique entre 

les espaces de noms et les URI. Deux espaces de noms ayant le même URI 

sont identiques. Tous les utilisateurs d’un même vocabulaire XML devraient s’entendre 

sur un même URI. Par exemple, l’URI de l’espace de noms du XHTML est 

« http://www.w3.org/1999/xhtml ». L’URI agit un peu comme le numéro d’assurance 

sociale des vocabulaires XML. Il s’agit d’une analogie un peu étrange, voire 

originale, mais c’est ainsi. 

Évidemment, la notion d’espace de noms n’a de sens que si l’on considère plusieurs 

espaces de noms et, par conséquent, plusieurs vocabulaires. 

1.8.6 Les DTD et les espaces de noms 

Avant de préciser le lien entre les DTD et les espaces de noms, il importe de comprendre 

que les espaces de noms furent proposés après l’adoption des DTD. Il y a donc 

une certaine incompatibilité entre les DTD et les espaces de noms. C’est d’ailleurs 

l’une des raisons pour laquelle plusieurs organismes, dont OASIS et le W3C, tentent 

de proposer des solutions de remplacement pour les DTD. 

Rappelons que l’on donne une DTD à un document, en ajoutant une déclaration de type 

de document, immédiatement après la déclaration XML, et dont la forme est : 

 

C’est la même chose avec les espaces de noms. Si vous avez, par exemple, un vocabulaire 

pour les expéditions et un vocabulaire pour les factures, définis respectivement 

par des DTD situées à : 

http://www.mondomain.com/expedition.dtd 

et 

http://www.mondomain.com/facture.dtd, 

vous ne pourriez pas combiner les deux vocabulaires ainsi : 

CC BY-NC-SA


 

Même si l’on pouvait combiner deux DTD de la sorte, cela aurait plusieurs inconvénients 

: quoi faire si les deux DTD définissent un élément « client », mais de façon 

différente La solution est de créer un nouveau vocabulaire XML qui combine les deux 

et traite chaque vocabulaire comme un « espace de noms ». 

Dans l’exemple qui suit, nous considérons deux vocabulaires, « facture » et « expedition 

» qui ont les DTD suivantes : 

 

 

 

 

 

 

 

 

1.8.7 Déclaration de l’espace de noms 

On peut utiliser le symbole « : » dans les noms XML, mais on ne l’utilise généralement 

qu’une seule fois dans un nom donné. Tout ce qui précède le deux-points est appelé le 

« préfixe ». 

On a vu qu’un espace de noms est identifié par un URI. À leur tour, les URI peuvent 

être associés à un « préfixe ». Tout attribut ou élément qui utilise un préfixe donné fait 

automatiquement partie de l’espace de noms identifié par l’URI. Seul l’URI identifie 

un espace de noms : le choix du préfixe est sans importance. Un document peut avoir 

un seul espace de noms, mais douze préfixes différents. 

On définit un « préfixe » à l’aide d’un attribut ayant comme préfixe « xmlns ». La 

définition du préfixe est alors valable pour l’ensemble de l’élément, y compris la balise 

où se situe l’attribut « xmlns: ». Ainsi, dans le document XML suivant : 

 

 

10$ 

Jean 

 

on reconnaît que l’élément « fact:facture » et tout son contenu utilisent l’espace de 

noms « http://www.domaine.com/facture » que nous avons décrit par une DTD plus 

CC BY-NC-SA


haut. Le préfixe « fact » est ici associé à l’URI « http://www.domaine.com/facture » 

et tous les éléments et attributs ayant le préfixe « fact » sont considérés faire partie de 

l’espace de noms « http://www.domaine.com/facture ». 

Il est « illégal » d’utiliser un préfixe qui n’a pas été défini... Ainsi, le document suivant 

est bien formé, mais il ne respecte pas les conventions des espaces de noms : 

 

 

10$ 

Jean 

 

Avez-vous remarqué que ces derniers documents n’ont pas de déclaration de type de 

document et ne peuvent donc pas être des documents XML valables La plupart des 

documents XML utilisant les espaces de noms sont dans ce cas. Si jamais nous avions 

une déclaration de type de document, il faudrait une DTD qui contiennent les éléments 

« fact:facture », « fact:montant » et « fact:nom ». En d’autres mots, ce nouveau document 

XML ne peut utiliser la DTD facture décrite plus haut. Nous ne traiterons pas de 

cette approche ici, car on combine rarement les DTD de la sorte. 

Le choix du préfixe « fact: » est arbitraire. On peut changer le nom du préfixe, car 

seul l’URI identifie de façon unique l’espace de noms. Par exemple, le document XML 

suivant est équivalent à celui que nous venons de décrire. 

 

 

10$ 

Jean 

 

On peut aussi redéfinir un préfixe comme dans l’exemple qui suit : 

 

 

 

10$ 

Jean 

 

Dans ce dernier cas, on dira que l’élément « montant » est dans l’espace de 

noms « http://www.domaine.com/facture2 » et non pas dans l’espace de noms 

« http://www.domaine.com/facture ». Tout élément et attribut, utilisant le préfixe 

« facture » dans l’élément « montant », seraient eux aussi dans l’espace de noms 

« http://www.domaine.com/facture2 ». 

CC BY-NC-SA


L’endroit où apparaît la déclaration d’espace de noms est aussi sans conséquence. Par 

exemple, les deux documents suivants sont équivalents : 

 

 

 

10$ 

Jean 

 

 

 

 

 

10$ 

Jean 

 

 

On dit que deux documents sont équivalents, au sens des espaces de noms, s’ils ne 

diffèrent que par les préfixes d’espaces de noms et par les endroits où apparaissent les 

déclarations d’espaces de noms. 

Évidemment, avec les espaces de noms, on peut combiner plusieurs vocabulaires. Par 

exemple, si nous voulons décrire une commande en utilisant les vocabulaires « facture » 

et « expedition », on peut très bien le faire comme le montre l’exemple suivant : 

 

 

10$ 

Jean 

 

 

Jean 

Bertrand 

1040, rue Jean 

 

 

 

En outre, on pourrait même combiner les espaces de noms de façon arbitraire comme 

le montre le prochain exemple : 

 

 

10$ 

CC BY-NC-SA


 

Jean 

Bertrand 


 

 

1.8.8 Les déclarations croisées 

La déclaration d’espace de noms n’est valable qu’au sein de l’élément. Pour déterminer 

l’espace de nom auquel appartient un élément, il ne suffit donc pas de remonter 

et de s’arrêter à la première déclaration que l’on trouve. Voyez si vous pouvez voir 

pourquoi l’espace de nom de l’élément « fact:montant » dans l’exemple suivant est 

« http://www.domaine.com/facture » et non « http://www.domaine.com/facture2 ». 

 

 

 

 

 

 

1.8.9 Le préfixe par défaut 

On peut utiliser le préfixe par défaut, c’est-à-dire ne pas mettre de préfixe du tout. 

L’utilisation du préfixe par défaut est optionnelle dans un document XML. Comme 

tout autre préfixe, le préfixe par défaut peut être réutilisé, redéfini plusieurs fois dans 

un même document. Voici un exemple de préfixe par défaut : 

 

 

10$ 

 

Jean 

Bertrand 


 

 

Notons cependant que le préfixe par défaut ne s’utilise que pour les éléments : les 

attributs sans préfixe ne sont dans aucun espace de noms, et cela sans exception. 

CC BY-NC-SA


1.8.10 Rappel des notions formelles 

La définition d’un préfixe d’espace de noms inclut l’élément où le préfixe est défini et 

tout son contenu, et rien d’autre. Le document qui suit fait une utilisation incorrecte 

des espaces de noms : 

 

 

 

 

 

 

parce que le préfixe « fact » n’est défini qu’au sein de l’élément « facture ». 

Bien que cela ne soit pas recommandable, il est possible de redéfinir les préfixes d’espace 

de noms. C’est simple si l’on se rappelle que la définition d’un préfixe inclut 

l’élément où la définition est faite. Ainsi, dans l’exemple : 

 

 

 

 

 

 

l’élément « nom » appartient à l’espace de noms « http://www.domaine.com/nom » et 

non à l’espace de noms « http://www.domaine.com/facture ». 

Par convention, on doit toujours accorder à un préfixe d’espace de noms un 

URI et il serait incorrect d’écrire au lieu de dans l’exemple précédent. 

1.8.11 Les espaces de noms et Relax NG 

Alors que les DTD ne permettent pas de traiter les espaces de noms, les spécifications 

Relax NG et XML Schema le permettent. L’utilisation des espaces de noms en Relax 

NG est particulièrement simple comme le montre cet exemple. 

namespace fact = "http://www.domaine.com/facture" 

namespace fact2 = "http://www.domaine.com/facture2" 

element fact:facture { 

element fact:nom {text}, 

element fact:montant {text}, 

element fact2:id {text} 

CC BY-NC-SA


} 

}* 

Le document XML suivant sera alors valable. 

 

 

Daniel 

10,80$ 

10,80$ 

 

Par défaut, il n’y a pas d’espace de noms lorsqu’un préfixe n’est pas utilisé, mais on 

peut définir l’espace de noms par défaut comme ceci : 

namespace fact = "http://www.domaine.com/facture" 

default namespace = "http://www.domaine.com/facture2" 

element fact:facture { 

element fact:nom {text}, 

element fact:montant {text}, 

element id {text} 

}* 

} 

Les deux exemples précédents de Relax NG sont d’ailleurs équivalents. 

1.8.12 Le préfixe « xml » 

Par convention, le préfixe « xml » est réservé à des applications telles que la 

déclaration de la langue utilisée (« xml:lang ») ou le traitement des espaces 

(« xml:space »). Il n’est pas nécessaire d’y associer explicitement un URI : l’URI 

« http://www.w3.org/XML/1998/namespace » y est automatiquement associé. 

1.8.13 Rappel : des espaces de noms pour les attributs 

Les choses se corsent un peu quand on considère les attributs. Alors qu’un élément sans 

préfixe tombe dans l’espace de noms par défaut si celui-ci a été défini par un attribut 

« xmlns="..." », ce n’est pas le cas pour les attributs. Un attribut sans préfixe n’est dans 

aucun espace de noms; pour y être, un attribut doit être muni d’un préfixe. 

CC BY-NC-SA


1.8.14 En résumé, qu’est-ce que les espaces de noms 

Une DTD définit un ensemble fixe d’éléments, ensemble qui ne peut être recombiné 

avec d’autres DTD; c’est un instrument rigide. Par contre, les espaces de noms 

permettent de recombiner des éléments provenant de différentes applications; ils permettent 

donc une grande flexibilité. 

Alors que la DTD définit des éléments et comment les utiliser ensemble, les espaces de 

noms ne permettent d’établir qu’un lien entre un élément et un URI, mais sans indiquer 

les contraintes d’utilisation. 


1. Choisissez l’expression qui décrit le mieux un espace de noms XML. Choisissez 

la bonne réponse parmi les choix suivants. 

(a) Un espace de noms XML est décrit par une DTD. 

(b) Un espace de noms XML est un ensemble de balises et d’attributs auquel 

peut correspondre un URI. 

(c) Un espace de noms XML est décrit par un URI qui est une adresse web 

pointant vers un document. 

2. Les espaces de noms font partie de la spécification XML originale (version 1.0) 

au même titre que les DTD. Choisissez la bonne réponse parmi les choix suivants. 

(a) Faux. 

(b) Vrai. 

3. Les espaces de noms permettent d’utiliser deux DTD en même temps. Choisissez 


(a) Faux. 

(b) Vrai. 

4. Les espaces de noms permettent d’utiliser deux vocabulaires XML en même 

temps. Choisissez la bonne réponse parmi les choix suivants. 

(a) Faux. 

(b) Vrai. 

5. Dans le document XML suivant, qu’est-ce qui décrit le mieux l’espace de noms 

de l’élément « B » 

 

abcd 

 

CC BY-NC-SA



(a) B 

(b) A 

(c) foo 

(d) http://www.bar.org/ 

6. Quelle est la différence entre ces deux documents XML 

 

abcd 

 

 

abcd 

 


(a) Il n’y a aucune différence puisque l’élément « A » est associé par défaut à 

l’URI « http://www.foo.org/ ». 

(b) Dans le premier cas, l’élément « A » est dans l’espace de noms « foo », 

alors que dans le second, « A » est dans l’espace de noms par défaut. 

7. Quel est l’espace de noms de l’élément « B » dans ce document 

 

 

abcd 

 

 


(a) http://www.mondomaine.org/ 

(b) http://www.monsite.org/ 

8. Quels sont les documents XML respectant les conventions des espaces de noms 


(a) 

 

 

 

abcd 

 

CC BY-NC-SA


 

 

(b) 

 

abcd 

efgh 

 

1234 

5678 

 

ijkl 

 

(c) 

 

 

 

9. Dans quels espaces de noms sont les attributs du document suivant : 

 

 

33 

 


(a) « base=’10’ » est dans l’espace de noms « urn:exemple1 », alors que 

« c:unite=’annee’ » est dans l’espace de noms « urn:exemple2 » 

(b) « base=’10’ » est dans l’espace de noms « "" » (vide), alors que 


(c) « base=’10’ » n’est dans aucun espace de noms, alors que 


10. Un parseur XML charge les URI associés aux espaces de nom qu’il rencontre. 


(a) Vrai 

(b) Faux 

CC BY-NC-SA



1. (a) Une DTD peut être utilisée, mais ce n’est pas la seule possibilité. 

(b) (Bonne réponse) En effet. 

(c) Un URI est une adresse symbolique qui ne pointe pas nécessairement vers 

un document. 

2. (a) (Bonne réponse) Bien que compatible avec la norme XML, les espaces de 

noms n’en font pas partie. 

(b) Bien que compatible avec la norme 1.0, les espaces de noms furent introduits 

plus tard, environ un an après. 

3. (a) (Bonne réponse) On peut utiliser une DTD ou ne pas en utiliser, mais on ne 

peut pas en utiliser deux. 

(b) Les espaces de noms ne changent rien à la validation des documents : il 

faut toujours avoir une seule DTD. 

4. (a) Les espaces de noms permettent effectivement d’utiliser plus d’un vocabulaire 

XML en même temps. 

(b) (Bonne réponse) On peut en fait combiner autant de vocabulaires XML que 

l’on veut. 

5. (a) Non. Il s’agit du nom de l’élément. 

(b) Non. Il s’agit d’un nom d’élément. 

(c) Non. « foo » est un préfixe d’espace de noms qui n’est pas utilisé dans le 

document par un élément. 

(d) (Bonne réponse) Effectivement. L’élément « B » appartient à l’espace de 

noms par défaut qui est associé à l’URI « http://www.bar.org/ ». 

6. (a) Non. 


7. (a) Non. L’espace de noms a été redéfini. 


8. (a) (Bonne réponse) Il n’y a rien qui nous empêche de redéfinir un espace de 

noms. 

(b) (Bonne réponse) Ce document est conforme. 

(c) Ce document est bien formé, mais pas conforme aux conventions d’espace 

de noms. Le préfixe « pre: » n’a pas été déclaré. 

9. (a) Non, « base » n’est dans aucun espace de noms, car il n’a pas de préfixe. 

(b) Il n’y a pas de raison que « base » soit dans l’espace de noms « "" ». 

(c) (Bonne réponse) Effectivement, un attribut sans préfixe n’est pas dans un 

espace de noms. 

10. (a) Non, l’URI n’est qu’un identifiant. 

(b) (Bonne réponse) Effectivement, l’URI peut ne pas pointer vers un véritable 

site web. 

CC BY-NC-SA

Travail noté 1 109 

1.9 Travail noté 1 

1.9.1 Objectifs et pondération 

Ce travail compte pour 10 % de la note globale du cours. 

Ce travail contribue à l’évaluation des objectifs suivants : 

– Utiliser un « vocabulaire » ou une application XML avec vocabulaire XML pour 

présenter des informations dans le format XML. 


– Interpréter des fichiers XML utilisant des espaces de noms. 

Les sept premières questions du travail valent 2,5 points chacune, la huitième vaut 3,5 

points; la neuvième question vaut 9 points, la dixième et la onzième valent 5 points 

chacune. Ce premier travail noté permet d’obtenir 40 points et compte pour 10 % de la 

note globale. 

1.9.2 Consignes 

Il est recommandé d’avoir terminé les activités d’autoévaluation du premier module 

avant de faire le travail noté. 

Vous devez remettre à la personne tutrice, par courriel et en fichier attaché, un document 

(Word 97/2000/XP, ODF, PDF, RTF ou en format texte) clairement identifié à votre 

nom. Indiquez également votre numéro d’étudiant (8 chiffres), la date du travail, le 

nom de la personne tutrice, avec les mentions « Travail noté 1 » et « INF 6450 ». 

Ne transmettez pas vos solutions en plusieurs fichiers. Ne transmettez pas une 

archive compressée (zip ou autre). Il s’agit d’un travail personnel et vous ne devez 

pas partager vos réponses. 

L’objet de votre courriel doit commencer par « [INF6450][TRAVAIL1] »; dans 

le message, indiquez votre nom, votre numéro d’étudiant (8 chiffres), la date de 

remise de votre travail et le nom de votre personne tutrice, ainsi que les mentions 

« Travail noté 1 » et « INF 6450 ». 

Lorsque le contenu d’un document XML fait partie d’une question, vous devez 

supposer que le document débute avec le premier caractère et se termine avec le 

dernier : il n’y a pas d’espace ou de retour de chariot, ni au début ni à la fin des 

fichiers XML, mais tous les autres espaces ou retours de chariot comptent. Vous 

devez également supposer que les documents ne sont pas enregistrés avec la norme 

UTF-8 ou UTF-16, mais plutôt avec un outil banal comme le Bloc-notes qui sélectionne 

par défaut un jeu de caractères similaire à ISO-8859-1. 

Bon travail! 

CC BY-NC-SA


Question 1 

Soit le document XML suivant : 

 

 

Davantage l’an prochain. 

 

 

 

1. Quel est le nom de l’élément-racine 

2. Combien d’éléments compte ce document 

3. Combien y a-t-il de balises dans ce document 

4. Combien y a-t-il de nœuds de texte dans ce document 

5. Combien d’attributs trouve-t-on dans ce document 

Question 2 


 

 

 

 

 

 

]> 

 

&administration; 


Marion Lepage 

 

1. Quel est le nom de l’élément-racine 

2. Quel est le contenu de l’élément « president » 

3. Quel est le contenu de l’élément « comptable » 

4. Est-ce qu’on pourrait omettre l’élément « adjoint » 

5. Combien d’éléments « president » peut contenir l’élément-racine 

CC BY-NC-SA


Question 3 


 

 

fraise, orange 

3 

 

 

1. À quel espace de noms, identifié par son URI, est-ce que l’élément « mots-clefs » 

appartient 

2. À quel espace de noms, identifié par son URI, est-ce que l’élément « recherche » 

appartient 

3. À quel espace de noms, identifié par son URI, est-ce que l’élément « yahoo:mot » 

appartient 

4. À quel espace de noms, identifié par son URI, est-ce que l’élément « nombre » 

appartient 

5. Combien y a-t-il d’espaces de noms dans ce document 

Question 4 

En utilisant un navigateur comme Mozilla Firefox, il est possible de déterminer 

si un document XML est bien formé. Dans cette question, nous vous demandons 

d’expliquer pourquoi les cinq documents présentés ci-dessous ne sont pas bien formés. 

Notez qu’on ne vous demande pas seulement d’indiquer où se trouve le problème 

ou de rapporter le message d’erreur qu’un outil vous donnerait. 

Expliquez clairement pourquoi les documents XML suivants ne sont pas bien formés. 

1. (Indice. Si Mozilla donne l’erreur suivante « XML Parsing Error: illegal parameter 

entity reference », expliquez ce que cela signifie!) 

 

 

 

 

 

CC BY-NC-SA


 

]> 

 



Marion Lepage 

 

2. 

 

Éric Beaudin 

automne 

Introduction aux affaires 

 

3. 

AWS Inc. 

SMS5SB11 

QC 

http://domaine.com/cgi-bin/script.plbox=sms5sb11&option=B 

 

4. 

 

124, rue Rochond 

 

5. 

 

Jean 

 

 

Jeanne 

 

Question 5 

Trouvez les 5 erreurs de validation du document suivant : 

 

 

 

 

 

]> 

CC BY-NC-SA


 

La plus grande. 

 

 

 

 

 

 

Question 6 

Soit le document DTD suivant : 

 

 

 

Il est situé à l’adresse « cours.dtd ». Écrivez un document XML pour décrire un cours 

de 3 modules qui s’intitulent respectivement : « 1. La vie sous-marine », « 2. La vie 

extraterrestre » et « 3. La vie supraterrestre ». Seul le troisième module est optionnel. 

Votre document XML doit être valable. 

Question 7 

Un document XML « normalisé » est tel que seul l’élément-racine contient des déclarations 

d’espace de noms. Écrivez un document XML qui soit équivalent à celui qui 

suit, au sens des espaces de noms : seul l’élément-racine contiendra des déclarations 

d’espace de noms. 

 

 

 

Jeanne Rigault 

 

 

 

Jean Perron 

 

 

MaCompagnie.com 

 

 

850$ 

 

 

CC BY-NC-SA


 

Daniel Legault 

 

 

Question 8 

Même question. 

 

 

 

 

 

 

 

 

Question 9 

Produisez un document XML contenant une DTD interne codifiant les spécifications 

suivantes; dans le cas où les DTD ne permettent pas de codifier une spécification, vous 

devez l’ignorer. 

Nous voulons représenter un annuaire (élément nommé « annuaire ») contenant aucun, 

une seule ou plusieurs personnes (élément nommé « personne »). L’élément « annuaire 

» peut avoir un attribut nommé « titre ». Les éléments « personne » sont constitués, 

dans l’ordre, d’un élément « nom » contenant du texte, d’un élément « prenom » 

contenant du texte, d’un ou plusieurs éléments « courriel » contenant du texte, d’un 

élément optionnel « commentaire » contenant du texte, et de un ou plusieurs éléments 

« ami » devant être vide, soit sans aucun contenu. 

Les éléments « personne » ont deux attributs, un attribut « type » qui peut prendre les 

valeurs « étudiant », « professeur », « tuteur » et « cadre » avec « étudiant » comme 

valeur par défaut, et un attribut obligatoire « nas » qui doit servir d’identifiant unique. 

Les éléments « ami » ont un attribut « nas » qui doit correspondre à la valeur d’attribut 

« nas » d’un des éléments « personne ». 

Question 10 

Un document DTD a été proposé par John Shipman pour présenter des recettes de 

cuisine (« recipe » est « recette » en anglais, alors qu’on pourrait traduire librement 

« subrecipe » par « sous-recette » et « narrative » par « description textuelle », puis 

« time » par « durée », comme dans « temps de cuisson ») : 

CC BY-NC-SA


 

 

 

 

 

 

 

 

 

 

 

 

 

 

Supposons que cette DTD est disponible à l’URL 

http://infohost.nmt.edu/tcc/help/xml/recipes/recipe.dtd 

Sur la base de cette DTD, produisez un document XML valable pour présenter une recette 

de votre choix. Il n’est essentiel qu’il s’agisse d’une vraie recette. Votre document 

XML doit utiliser tous les éléments et attributs définis par le document DTD. Vous devrez 

peut-être imaginer une recette un peu compliquée! Votre document doit avoir une 

déclaration XML et utiliser au moins un accent. 

Question 11 

Quel est l’équivalent en DTD du fichier Relax NG suivant 

carte = element carte { attribute courriel { text }, text } 

page = element page { text } 

livre = element livre { (carte | page) } 

CC BY-NC-SA

Module 2 : XML en tant que 

syntaxe pour les documents 

2.1 Aperçu 


À la fin de ce module, vous devriez avoir approfondi votre compréhension du XML 

à l’aide d’exemples et mieux voir le rôle qu’il peut jouer dans votre organisation. En 

effet, il n’est pas suffisant de savoir ce qu’est le XML en tant que métalangage, il faut 

également comprendre d’où il vient et quel rôle il joue dans son domaine de prédilection 

: le web. L’objectif spécifique du module est : 


informations. 

Pour atteindre cet objectif, nous vous proposons deux activités notées, soit une discussion 

de groupe sur le marquage sémantique et la rédaction d’un texte en utilisant le 

XML. Les lectures et les activités d’autoévaluation de ce module servent à alimenter et 

à préparer les activités notées. 


Vous devez effectuer les lectures de ce module avant de passer aux modules suivants. 

Nous vous invitons à procéder à l’étude de ce module dans l’ordre suivant : 

– Introduction au XHTML, MathML et SVG 

– XML comme format de documents (SGML, DocBook, ODF) 

– XML sur le web 

S’il y a lieu, vérifiez vos connaissances en répondant au questionnaire d’autoévaluation. 

117


Par ailleurs, à partir du moment où vous commencez l’étude du module 2, vous pouvez 

entreprendre le travail noté 2, soit l’activité de discussion en groupe dans le forum, laquelle 

peut s’étendre sur tout le cours (participation au forum). Vous pouvez toutefois 

commencer cette discussion (travail noté 2) plus tard dans le cours. Par contre, le 

module se termine par le travail noté 3, soit la rédaction d’un texte avec XML, que vous 

devez réaliser avant de passer au module suivant. 

Le pense-bête offre un rappel du HTML; dans la version imprimée du cours, il se trouve 

en annexe. 

2.2 Introduction au XHTML 


Connaître les notions de base du XHTML. 


Lisez le texte qui suit, avant de lire les deux autres suggérés dans ce module. C’est un 

impératif pour bien progresser dans votre apprentissage du XML. 

2.2.3 Qu’est-ce que le XHTML 

Le HTML a été inventé par Tim Berners-Lee, alors qu’il travaillait pour le centre de 

recherche CERN en Suisse. L’intention de Berners-Lee était de proposer un système révolutionnaire 

de gestion de l’information qu’il appela World Wide Web. Comme pièce 

maîtresse de son architecture, il avait besoin d’un format de documents qu’il appela 

HTML (HyperText Markup Language). La première page web, dont l’adresse était 

http://nxoc01.cern.ch/hypertext/WWW/TheProject.html, vit le jour en 1990. 

Le HTML est un langage à base de balises, un peu comme une application XML. En 

fait, il existe une application XML appelée XHTML, qui est à la fois du HTML et 

du XML. Le document que vous lisez en ce moment en est un exemple. En effet, le 

document que vous lisez est à la fois du XML bien formé et valable, mais aussi 

du HTML. 

Rappelons qu’une « application XML » est un ensemble de balises et d’attributs, c’està-dire 

un vocabulaire XML, avec des conventions d’usage dont certaines peuvent être 

représentées par un document DTD. 

La très grande majorité des documents sur le web sont écrits en HTML et, de plus en 

plus, en XHTML. Une des raisons principales de l’utilisation du XHTML, c’est que 

les outils qui traitent le XML peuvent aussi traiter du XHTML puisque ce dernier est 

aussi du XML. Il est donc possible, dans une organisation, de combiner le contenu 

CC BY-NC-SA

Introduction au XHTML 119 

web (HTML) avec le stockage des informations en XML. Comme nous le verrons plus 

tard dans le cours (module 3, section portant sur le XSLT), on peut même transformer 

automatiquement le XML en XHTML. 

Si on dit « HTML » tout court, ce n’est pas nécessairement du XML et il se peut que 

les outils conçus pour le XML ne puissent être utilisés pour le traiter. Cependant, si 

on dit « XHTML », alors il s’agit à la fois de HTML et de XML et on peut utiliser 

les outils destinés au XML pour en traiter le contenu. Voici quelques différences entre 

le HTML et le XHTML : 

Les serveurs web distinguent le contenu en fournissant aux navigateurs différents 

codes MIME (Multipurpose Internet Mail Extensions), alors que le HTML a le code 

MIME « text/html », on utilise le code MIME « application/xml » ou « application/xhtml+xml 

» pour le XHTML. Avec le serveur web Apache, on obtient le résultat 

désiré en ajoutant un fichier « .htaccess », dans le même répertoire que nos fichiers 

XHTML, contenant la ligne « AddType application/xml .xhtml ». 

– En HTML traditionnel, on n’a pas à fermer les éléments. Ainsi, le code suivant 

« texte » est acceptable en HTML, mais en XHTML, il faut écrire 

« texte ». 

– Les valeurs d’attributs en HTML n’ont pas à être entre des guillemets ou apostrophes. 

Ainsi, le code « » est acceptable en HTML, mais en 

XHTML, il faut écrire « ». 

– En HTML, la casse des noms est sans importance. Ainsi, on peut remplacer « » 

par « », alors que ce n’est pas permis en XHTML. 

Dans ce cours, nous nous intéresserons surtout au XHTML. Un document XHTML 

prend la forme suivante : 

 

 

 

 

Titre de mon document 

 

 

Voici mon document. 

 

 

On reconnaît d’abord la déclaration XML qui n’a rien de particulier : . Comme pour tout document XML, on peut 

omettre la déclaration XML d’un document XHTML, mais si nous voulons écrire en 

français avec des lettres accentuées, il est nettement préférable d’avoir la déclaration 

XML de notre exemple. 

CC BY-NC-SA


On reconnaît ensuite la déclaration de type de document : . Observez qu’elle apparaît sur deux lignes, que c’est souvent le cas, mais 

que c’est un choix purement esthétique. La déclaration de type de document est un peu 

particulière : il s’agit d’une déclaration utilisant un identifiant public. On doit utiliser 

un tel identifiant quand on veut signifier qu’il s’agit d’une application XML commune; 

on évite ainsi que des milliers de personnes aillent chercher des documents DTD à 

l’adresse « http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd ». On s’attend qu’un 

logiciel qui dépend d’une application XML commune n’ait pas besoin d’aller chercher 

les documents DTD, chaque fois que le document XML est lu. Un navigateur comme 

Firefox ne tient pas compte de la DTD externe, on peut donc omettre la déclaration 

DOCTYPE sans problème. 

Le reste du document est simplement un élément-racine « html » contenant deux 

éléments : un élément head et un élément body. L’élément head doit contenir un 

élément title, alors que l’élément body peut être vide, mais peut aussi posséder du 

contenu XML mixte (texte et diverses balises XHTML). L’espace de nom ayant l’URI 

« http://www.w3.org/1999/xhtml » est utilisé. 

Si vous copiez le texte qui précède dans un éditeur de texte comme Bloc-notes et que 

vous enregistrez le fichier sous un nom comme « test.xhtml », vous devriez être capable 

d’ouvrir le fichier dans votre navigateur et de voir le texte « Voici mon document. » 

s’afficher à l’écran. Les documents HTML sont tous des documents en format texte et 

l’extension du fichier est arbitraire : on utilise tout aussi bien « .htm » que « .html », 

« .xhtml » ou même « .xml ». L’avantage de l’extension « .xhtml » est d’informer 

le navigateur qu’il s’agit d’un document XHTML, donc un document HTML et un 

document XML. 

2.2.4 La structure du document XHTML : head et body 

Comme nous le disions, l’élément-racine d’un document XHTML est nommé « html ». 

Cet élément contient deux et exactement deux sous-éléments : head et body. L’élément 

head n’est pas affiché directement dans le navigateur et contient des métadonnées, 

c’est-à-dire une description du contenu. Un élément head doit au minimum contenir 

un élément title qui donne le titre du document XHTML. Par la suite, l’élément body 

contient un ensemble de balises et du texte (contenu mixte) qui sera affiché directement 

dans le navigateur. 

2.2.5 Les paragraphes en HTML 

L’élément body contient des balises et du texte. Les retours de ligne sont traités comme 

des espaces normaux. Ainsi, les deux documents suivants seront affichés de la même 

manière par un navigateur. 

 

CC BY-NC-SA


 

 

 


 

 


Voici ma vie. 

Voici mon chat. 

 

 

 

 

 

 


 

 


Voici ma vie. 


 

 

La question qui se pose alors est : Comment faire des paragraphes En effet, dans 

les deux documents plus haut, le texte s’affichera sur une seule ligne (vous pouvez 

le tester!). La solution consiste à utiliser l’élément « p » pour « paragraphe ». Pour 

avoir trois paragraphes, on remplace le document HTML précédent par celui qui suit. 

Observez que chaque balise « p » ouverte doit être fermée. 

 

 

 

 


 

 


Voici ma vie. 


 

CC BY-NC-SA


 

2.2.6 Les listes en HTML 

Supposons que l’on veuille faire une liste, comme ceci : 

– Premier point : le chat est noir. 

– Second point : le chat est blanc. 

– Dernier point : le chat est marron. 

On peut obtenir ce résultat avec un élément « ul » pour unordered list (liste sans ordre), 

contenant des éléments « li ». Observez que chaque balise « li » ouverte doit être 

fermée. 

 

 

 

 


 

 

 

Premier point: le chat est noir. 

Second point: le chat est blanc. 

Dernier point: le chat est marron. 

 

 

 

Supposons maintenant que nous voulions une liste avec un compteur : 

1. Le chat est noir. 

2. Le chat est blanc. 

3. Le chat est marron. 

Il suffit alors de remplacer l’élément « ul » par l’élément « ol » pour ordered list (liste 

ordonnée) : 

 

 

 

 


 

 

CC BY-NC-SA


 

Le chat est noir. 

Le chat est blanc. 

Le chat est marron. 

 

 

 

2.2.7 Les tableaux en HTML 

Supposons maintenant que nous voulions produire un tableau. On peut l’obtenir à l’aide 

d’un élément « table ». Cet élément contiendra plusieurs éléments « tr » (éléments 

correspondant à une ligne) qui eux-mêmes contiennent des éléments « td » (éléments 

correspondant à une cellule). Ainsi, pour obtenir un tableau comme celui-ci : 

Nom 

Valeur 

Mustang 50 $ 

Ferrari 500 $ 

On utilise le code suivant : 

 

 

 

 


 

 

 

 

Nom 

Valeur 

 

 

Mustang 

50 $ 

 

 

Ferrari 

500 $ 

 

 

 

 

CC BY-NC-SA


Supposons maintenant que l’on veuille un tableau avec des lignes pour marquer et 

diviser les cellules. Il suffit alors d’utiliser l’attribut « border ». Sa valeur numérique 

représente l’épaisseur en pixels de la bordure. Ainsi, pour obtenir ce résultat : 

Nom 

Valeur 

Mustang 50 $ 

Ferrari 500 $ 

On utilisera le code XHTML suivant : 

 

 

 

 


 

 

 

 

Nom 

Valeur 

 

 

Mustang 

50 $ 

 

 

Ferrari 

500 $ 

 

 

 

 

Tous les tableaux ne sont pas si simples. On peut faire en sorte qu’une même cellule 

occupe deux colonnes () ou deux rangées (). Aussi, 

souvent, on utilise l’élément « th » au lieu de l’élément « td » pour désigner la première 

rangée d’un tableau lorsque celle-ci forme l’entête descriptive du tableau. Il est aussi 

possible d’utiliser un élément « caption » au sein d’un tableau pour noter le titre du 

tableau : 

 

 

 

 


CC BY-NC-SA


 

 

 

Valeur de différents véhicule 

 

Nom 

Valeur 

 

 

Mustang 

50 $ 

 

 

Ferrari 

500 $ 

 

 

 

 

2.2.8 Les caractères italiques et gras 

On peut très facilement utiliser des effets de polices de caractères en HTML. Pour 

obtenir des caractères en italique, par exemple maman, il suffit d’utiliser un élément 

« i » comme ceci : maman. Pour des caractères en gras, comme maman, 

il suffit d’utiliser un élément « b » comme ceci : maman. On peut également 

combiner les deux, comme maman, en écrivant maman ou bien 

maman. Il est cependant préférable d’utiliser « em » (emphase) au lieu 

de « i » et « strong » (fort) au lieu de « b » : le navigateur choisira alors de rendre le 

texte dans un élément « em » avec un italique ou une autre technique appropriée, et de 

rendre le texte dans un élément « strong » en caractères gras ou une autre technique 

appropriée. On évite ainsi de confondre la présentation (italique ou gras) et la sémantique 

(emphase ou point fort). Dans le cas où un terme est défini, vous devriez utiliser 

un élément « dfn » (définition) comme dans cet exemple: « La mort est la 

fin de la vie ». La plupart des navigateurs afficheront alors le mot « mort » en caratères 

italiques. 

2.2.9 Les listes de définitions 

Supposons que nous voulions une liste de définitions comme celle qui suit : 

Voiture Véhicule sur roues. 

Chat Bête sauvage qui se nourrit de lait. 

CC BY-NC-SA


Éléphant Bête sauvage de couleur rose. 

On obtient ce résultat en XHTML avec un élément « dl » pour definition list contenant 

une série d’éléments « dt » et « dd » en paire, où l’élément « dt » fournit le terme à 

définir et l’élément « dd » sa définition. 

 

 

 

 


 

 

 

Voiture 

Véhicule sur roues. 

Chat 

Bête sauvage qui se nourrit de lait. 

Éléphant 

Bête sauvage de couleur rose. 

 

 

 

2.2.10 Les lignes horizontales 

Pour obtenir une ligne horizontale, on utilise l’élément « hr » qui doit être vide. On 

doit donc écrire ou plus simplement . Voici une ligne horizontale : 

2.2.11 Les images 

Au moment d’écrire ces lignes, on trouve un logo de l’UQÀM à l’URL 

http://www.uqam.ca/img/logo/logo.jpg. 

Pour insérer une image dans un document HTML, il suffit d’utiliser une balise « img » 

avec comme attribut « src » pour source, soit l’URL. Par exemple, le code 

 

ou 

 

CC BY-NC-SA


permettra d’insérer le logo de l’UQÀM dans un document. Il est préférable de prévoir 

que l’image pourrait ne pas être trouvée ou affichée en ajoutant un attribut « alt » qui 

contient du texte décrivant le contenu de l’image; si l’image n’est pas disponible, le 

texte contenu dans l’attribut « alt » s’affichera. Le résultat final prend la forme ce qui donne : 

2.2.12 Les hyperliens 

Pour inclure un hyperlien, comme dans l’exemple de la page de l’UQÀM 

[lien vers http://www.uqam.ca/], il suffit d’utiliser la syntaxe « page de l’UQÀM ». 

On peut également ajouter des marqueurs dans une page web en utilisant la syntaxe 

« Premier point de mon document ». Contrairement à la syntaxe 

« », l’attribut « name » n’ajoute pas un hyperlien, mais un marqueur 

généralement invisible dans la page. Par exemple, si la page contient plusieurs sections, 

on peut ajouter un marqueur au début de chaque section. On pourra alors faire des liens 

non seulement vers le document, mais aussi vers la section marquée dans le document. 

Ainsi, l’hyperlien « aller vers le premier point du document 

pageweb.html » mènera l’utilisateur dans le document « pageweb.html », 

précisément au marqueur du « point 1 », s’il existe, évidemment. 

2.2.13 Les abbréviations 

On utilise parfois des abbréviations dans une page web tel que « etc. » ou « no ». 

On peut indiquer au navigateur qu’il s’agit d’une abbréviation avec un élément 

abbr comme ceci : « no ». Il est parfois utile d’utiliser l’attribut 

« title » pour décrire l’abbréviation en question comme dans ceci : « no ». De la même façon, on peut noter les acronymes avec 

un élément « acronym » comme ceci : « OTAN ». 

2.2.14 Les adresses 

Il est fréquent qu’une page web contienne un adresse. Le XHTML nous permet d’indiquer 

au navigateur qu’il s’agit bien d’une adresse avec l’élément « address », comme 

ceci : « Daniel Lemire 100, rue Sherbrooke ». Ici, l’élément 

« br » sert à noter un retour de charriot. 

CC BY-NC-SA


2.2.15 Les indices et exposants 

Dans un texte, il arrive qu’on veuille utiliser des exposants et des indices. Les éléments 

« sup » et « sub » servent à cette fonction. Par exemple, « premier » peut s’écrit « 1 er 

». Il n’est malheureusement pas possible de noter automatiquement des notes en bas de 

page en HTML ou XHTML. 

2.2.16 Le code et les exemples 

Il y a plusieurs éléments permettant de traiter de la programmation informatique ou des 

mathématiques. Le code informatique peut s’écrire dans un élément « code ». Le texte 

saisi à l’écran par un utilisateur peut s’écrire dans un élément « kbd ». Les exemples de 

sortie à l’écran peuvent s’écrire dans un élément « samp » (pour sample) et les variables 

peuvent s’écrire dans un élément « var ». Voici un exemple : « La valeur de la variable 

i est obtenue avec ce code:int i = 1; i+=1On 

s’attend à ce que l’utilisateur tape Yes pour oui. Voici un exemple de résultat: 

Error!. ». 

2.2.17 Les citations 

Pour citer quelqu’un, on peut utiliser un élément « q » lorsqu’il s’agit d’un courte 

citation au sein d’un paragraphe ou élément « blockquote » lorsque la citation doit 

former un court paragraphe. Plusieurs navigateur mettent automatiquement le contenu 

de l’élément « q » entre guillemets et le contenu de l’élément « blockquote » en retrait. 

Voici un exemple : « Jean a dit: mon cher!. Par la suite, je lui ai lu ce 

texte fatidique.Oh! Comme la mer a merée! Oh! Comme j’ai 

jéjé! ». 

2.2.18 Les révisions 

Les éléments del et ins permettent de noter un retrait et un ajout, respectivement, 

comme dans cet exemple: « J’ai mariéépousé ta mère ». Le 

navigateur se chargera d’afficher les retraits et les ajouts de manière compréhensible. 

2.2.19 La langue 

Le XHTML respecte la spécification XML voulant qu’on indique la langue dans laquelle 

est écrite un texte avec l’attribute « xml:lang ». Cet attribut est optionnel, 

mais peut s’avérer pratique. Dans le cas où un texte en langue étrangère est présent 

dans un paragraphe, on peut utiliser l’élément « span » pour en indiquer la 

CC BY-NC-SA


langue. Voici un exemple : « Jean aime les computers ». L’élément « span » ne sert qu’à nous permettre de sélectionner 

un texte au sein d’un autre élément. 

2.2.20 Les commentaires 

Ajouter des commentaires en XHTML est facile. Les commentaires du XML s’appliquent: 

il suffit de débuter le commentaire par . Il n’est 

pas permis d’inclure au sein d’un commentaire deux tirets (--) ni de terminer un commentaire 

par un tiret. 

2.2.21 Séparation du contenu et de la présentation 

Avec le XHTML, on peut contrôler en partie l’apparence du texte, en utilisant des italiques 

ou en plaçant des bordures dans nos tableaux. Ce contrôle est cependant limité : 

on ne peut pas ajuster l’indentation des paragraphes et on ne peut que difficilement 

ajuster les marges de la page. Nous verrons au module 3, dans la section sur le CSS, 

qu’il existe une façon élégante d’y arriver. 

2.2.22 SVG 

On utilise de plus en plus la norme Scalar Vector Graphics (SVG) pour dessiner des 

figures en utilisant le XML. Le fichier suivant représente un rond jaune avec le texte 

« INF 6450 » au centre et deux lignes par dessus formant un X (notez les éléments 

« rect », « circle », « text » et « line »). Vous pouvez l’enregistrer sur votre disque et 

l’ouvrir avec Firefox (version 2.0 ou mieux). Vous pouvez déjà utiliser le format SVG 

avec plusieurs logiciels de bureautique ou tout simplement insérer un élément « svg » 

dans un document XHTML. 

Voici le code d’une image SVG. 

 

 

 

 

 

INF 6450 


style="stroke:rgb(99,99,99);"/> 

 

 

Voici le rendu de l’image par votre navigateur. 

La signification des divers éléments devraient être claire. L’élément « svg » définit la 

planche à dessin avec sa largeur et sa hauteur. L’élément « rect » trace un rectangle à 

partir de deux coins opposés (0,0 et 300,300 dans notre exemple) . L’élément « circle » 

trace un cercle avec un centre et un rayon donnés. L’élément line trace une ligne 

d’un point à un autre. L’élément text inclut du texte à la position donnée. Il est aussi 

possible de tracer des ellipses et des formes arbitraires. Il est même possible d’animer 

du SVG. 

Il est facile d’apprendre le SVG par l’exemple si vous avez des notions de graphisme. 

Le site suivant comprend plusieurs exemples instructifs : http://www.w3schools.com/ 

svg/svg_examples.asp. Vous pouvez aussi utiliser un logiciel de graphisme gratuit 

comme Inkscape (disponible sur les plate-formes Apple, Windows et Linux, voir http:/ 

CC BY-NC-SA


/www.inkscape.org/). Le site mozilla.org comprend une description complète du SVG 

(http://developer.mozilla.org/en/docs/SVG) tel qu’il est utilisé dans Firefox. 

2.2.23 MathML 

De la même façon qu’on peut représenter des graphiques en XML, on peut aussi représenter 

des formules mathématiques (supporté par Firefox 1.0 ou mieux). La syntaxe 

MathML est complexe et nécessite une bonne maîtrise de la typographique mathématique. 

Les éléments de bases d’une équation MathML sont « mi » (pour les variables 

ou fonctions), « mn » (pour les nombres) et « mo » (pour les opérateurs). D’autres 

éléments viennent s’ajouter comme « msup » (mise en exposant). On peut insérer un 

élément « math » directement dans un fichier XHTML. Il arrive malheureusement que 

des polices de caractères manquantes empêchent l’affichage correcte de la formule. 

Voici la formule « x 2 +x+2 » en MathML. 

 

x2 

+ 

x 

+2 

x 2 + x + 2 

Vous pouvez utiliser des outils en ligne tel que itex2MML pour écrire vos équations. 

2.2.24 Convertir du HTML mal formé 

Dans une organisation, il est fréquent d’avoir à composer avec des sites web qui ne 

respectent pas les normes les plus élémentaires. Réécrire le HTML en XHTML peut 

sembler une tâche très ardue. Heureusement, il existe des outils gratuits pour corriger 

du HTML mal formé et générer automatiquement un XHTML valable, comme 

par exemple HTMLTidy (http://tidy.sourceforge.net/). Le W3C rend aussi disponible 

un outil de vérification en ligne des sites web pour s’assurer de leur conformité avec 

les normes (http://validator.w3.org/). Vous pourrez facilement constater que plusieurs 

pages à l’UQÀM ne sont pas du HTML valable, y compris certaines pages web de ce 

cours ! 

2.2.25 Spécification Relax NG 

Il existe des définitions de type de document officielle pour le XHML, mais elles sont 

longues et peu lisible. Sean B. Palmer a écrit une spécification Relax NG pour un sousensemble 

du XHTML que je reproduis ici avec permission. Je vous invite à vérifier que 

vous pouvez en comprendre l’essentiel. 

CC BY-NC-SA


default namespace html = "http://www.w3.org/1999/xhtml" 

# Common Attributes 

Core.attrs = 

attribute id { xsd:ID }, 

attribute class { text }, 

attribute style { text }, 

attribute title { text } 

I18n.attrs = 

attribute xml:lang { text }, 

attribute dir { "ltr" | "rtl" } 

Main.attrs = 

Core.attrs, I18n.attrs, 

attribute onclick { text } 

# Content Models 

BlockMinusForm = 

(address | blockquote | del | div.elem | dl | h1 | h2 | 

h3 | hr | ins | ol | p | pre | script | table | ul)* 

Block = (BlockMinusForm | form)* 

InlineMinusMedia = 

(a | abbr | br | cite | code | del | em | input | ins | 

label | script | span | strong | sub | sup | textarea | text)* 

Inline = (InlineMinusMedia | img | object)* 

Flow = (Block | Inline)* 

# Elements 

start = html 

html = element html { 

I18n.attrs, 

head, body 

} 

head = element head { 

I18n.attrs, 

attribute profile { text }, 

title, base, (script* & style* & meta* & link*) 

} 

CC BY-NC-SA


title = element title { 

I18n.attrs, 

text 

} 

base = element base { 

attribute href { text }, 

empty 

} 

meta = element meta { 

I18n.attrs, 

attribute content { text }, 

attribute name { text }, 

empty 

} 

link = element link { 

Main.attrs, 


attribute rel { text }, 

attribute type { text }, 

empty 

} 

style = element style { 

I18n.attrs, 


attribute title { text }, 

text 

} 

script = element script { 


attribute src { text }, 

text 

} 

body = element body { 

Main.attrs, 

attribute onload { text }, 

Block 

} 

div.elem = element div { 

CC BY-NC-SA


} 

Main.attrs, 

Flow 

p = element p { 

Main.attrs, 

Inline 

} 

h1 = element h1 { 

Main.attrs, 

Inline 

} 


Main.attrs, 

Inline 

} 


Main.attrs, 

Inline 

} 

ul = element ul { 

Main.attrs, 

li+ 

} 

ol = element ol { 

Main.attrs, 

li+ 

} 

li = element li { 

Main.attrs, 

Flow 

} 

dl = element dl { 

Main.attrs, 

(dt, dd+)+ 

} 

dt = element dt { 

Main.attrs, 

CC BY-NC-SA


} 

Inline 

dd = element dd { 

Main.attrs, 

Flow 

} 

address = element address { 

Main.attrs, 

Inline 

} 

hr = element hr { 

Main.attrs, 

empty 

} 

pre = element pre { 

Main.attrs, 

InlineMinusMedia 

} 

blockquote = element blockquote { 

Main.attrs, 

attribute cite { text }, 

Block 

} 

ins = element ins { 

Main.attrs, 


Flow 

} 

del = element del { 

Main.attrs, 


Flow 

} 

a = element a { 

Main.attrs, 


attribute rel { text }, 

(text & img* & span*) 

CC BY-NC-SA


} 

span = element span { 

Main.attrs, 

Inline 

} 

br = element br { 

Core.attrs, 

empty 

} 

em = element em { 

Main.attrs, 

Inline 

} 

strong = element strong { 

Main.attrs, 

Inline 

} 

code = element code { 

Main.attrs, 

Inline 

} 

cite = element cite { 

Main.attrs, 

Inline 

} 

abbr = element abbr { 

Main.attrs, 

Inline 

} 

sub = element sub { 

Main.attrs, 

Inline 

} 

sup = element sup { 

Main.attrs, 

Inline 

} 

CC BY-NC-SA


object = element object { 

Main.attrs, 

attribute data { text }, 


Flow 

} 

img = element img { 

Main.attrs, 

attribute alt { text }, 

attribute src { text }, 

attribute height { text }, 

attribute width { text }, 

empty 

} 

form = element form { 

Main.attrs, 

attribute action { text }, 

attribute method { text }, 

BlockMinusForm 

} 

label = element label { 

Main.attrs 

} 

input = element input { 

Main.attrs, 

attribute type { "text" | "submit" | "hidden" }, 


attribute size { text }, 

attribute value { text }, 

empty 

} 

textarea = element textarea { 

Main.attrs, 

attribute cols { text }, 

attribute rows { text }, 


text 

} 

table = element table { 

CC BY-NC-SA


} 

Main.attrs, 

caption, tr+ 

caption = element caption { 

Main.attrs, 

Inline 

} 

tr = element tr { 

Main.attrs, 

(th | td)+ 

} 

th = element th { 

Main.attrs, 

Flow 

} 

td = element td { 

Main.attrs, 

Flow 

} 

2.2.26 HTML 5 

Une nouvelle spécification du XHTML et du HTML appelée HTML 5 est en préparation. 

Elle est compatible avec les syntaxes HTML 4 et XHTML qu’elle vise à remplacer. 

Un document HTML 5 peut prendre la forme d’un document XML ou d’un 

document HTML. La déclaration doctype n’est utilisée que dans le cas où le document 

n’est pas un document XML et a été grandement simplifiée : il suffit d’inclure la ligne 

au début du fichier. Voici un exemple de document HTML 5 : 

 

 

 

 

Ceci est un exemple 

 

 

Voici un paragraphe. 

 

 

Un document HTML 5 en XML ne nécessite pas de déclaration doctype : 

CC BY-NC-SA


 

 

 

Ceci est un exemple 

 

 

Voici un paragraphe. 

 

 

En HTML 5, on n’utilise plus les éléments acronym et plusieurs autres éléments moins 

utiles (basefont, big, center, s, strike, tt, u, frame, frameset, noframe, applet, isindex, 

dir). Plusieurs nouveaux éléments ont été ajoutés notamment les éléments section et 

article. On peut aussi ajouter une figure à un document avec une légende: 

 

 

Exemple d’image 

 

Les éléments canvas, video et audio sont aussi ajoutés : le HTML devient pleinement 

multimédia. 


Le XHTML est un vocabulaire XML. Vous pouvez en consulter la DTD en ligne, à 

l’adresse http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd; il ne s’agit pas d’une 

DTD facile à lire, mais elle est néanmoins disponible. Notez qu’il existe de très bons 

livres de référence pour approfondir le XHTML, mais pour ce cours, il suffit de 

connaître les quelques balises présentées dans ce document. 

Un des avantages importants du XHTML sur des pages web traditionnelles (souvent 

mal formées) est qu’on peut facilement traiter des pages XHTML avec des outils destinés 

au XML. Par exemple, à partir des pages XHTML et XML de ce cours, j’ai pu 

créer automatiquement une version PDF du cours. En somme, on peut plus facilement 

extraire et traiter l’information d’une page XHTML que l’on peut le faire d’une page 

HTML mal formée. 

Pour avoir une vue d’ensemble des notions étudiées, consultez le pense-bête sur 

le HTML. 


– Jennifer Robbins, HTML and XHTML Pocket Reference, O’Reilly Media, 2006, 97 

pages. 

CC BY-NC-SA


– Jean Engels, XHTML et css : cours et exercices, Eyrolles, 2006. 

2.2.29 Activité d’autoévaluation 

Afin de vous assurez d’avoir bien compris les notions présentées dans cette leçon, 

vous devez créer un document XHTML valable, utilisant les différents éléments que 

nous avons étudiés. Afin que votre navigateur reconnaisse le document comme étant 

du XHTML, vous devriez utiliser l’extension « xthml ». Si vous déposez le fichier sur 

un serveur web Apache, il peut être nécessaire de créer aussi un fichier « .htaccess » 

et de le déposer dans le même répertoire que votre fichier XHTML afin que le serveur 

puisse reconnaître les fichiers XHTML. Votre fichier « .htaccess » pourrait avoir le 


DirectoryIndex index.xhtml index.html index.php index.pl index.cgi 

AddType application/xml .xhtml 

2.3 XML comme format de documents 


Comprendre le XML comme format de documents. 


Après avoir lu Introduction au XHTML, lisez le texte qui suit, puis répondez au questionnaire 

d’autoévaluation. 

Ce texte porte sur plusieurs formats de documents avec balises. D’abord, il y a le 

HTML que nous avons présenté, qui est un format de documents pour le web; et comme 

nous l’avons vu, il existe une version XML du HTML, appelée XHTML, qui est à la 

fois du XML et du HTML. 

2.3.3 Le SGML (Standardized General Markup Language) 

En 1969, Charles Goldfarb, Edward Mosher et Raymond Lorie ont inventé le 

GML (Generalized Markup Language). Chercheurs chez IBM, ils voulaient faciliter 

l’échange d’informations entre les outils d’édition, de formatage et de recherche de 

documents. Le GML possédait déjà un concept de « type de documents » similaire 

aux documents DTD modernes. Chez IBM, le GML a été utilisé pour la production 

d’environ 90 % des documents électroniques. 

CC BY-NC-SA

XML comme format de documents 141 

En 1978, l’American National Standards Institute (ANSI) a travaillé sur un projet de 

langage de description de textes, basé sur le GML; le projet s’est terminé en 1985 par 

la normalisation du SGML. Le centre de recherche CERN a été l’une des premières 

institutions, outre IBM, à mettre au point des outils pour le SGML. 

On dit souvent que le SGML est l’ancêtre du XML, dans la mesure où les créateurs 

du XML connaissaient le SGML et voulaient faire mieux. Le HTML est aussi fortement 

inspiré du SGML et existait au moment où le XML a été proposé. Il n’est donc pas 

surprenant que le XML et le HTML se ressemblent et puissent même se retrouver dans 

un seul format, le XHTML. La principale difficulté avec le SGML est sa complexité. 

On considère généralement que partout où le SGML était utilisé, il est maintenant préférable 

d’utiliser le XML. Comme les deux normes sont similaires, on migre souvent 

du SGML au XML. Quoiqu’il y ait de petits ennuis de conversion, le passage au XML 

permet de traiter les nouveaux documents avec les nombreux outils XML et de suivre 

la tendance. 

Le SGML n’est pas très différent du XHTML. Par exemple, les paragraphes sont spécifiés 

avec des éléments « para » de la même façon qu’ils sont spécifiés avec des éléments 

« p » en XHTML. 

2.3.4 Le XML comme format de documents 

Notons que le SGML, le HTML et le XML sont avant tout des formats de documents. 

On utilise maintenant le XML comme outil de programmation pour stocker et pour 

échanger des informations entre les logiciels; toutefois, l’objectif des créateurs du XML 

n’était que de créer un format de documents simple et pratique. 

Pour les documents, un des avantages des nombreux formats basés sur le XML ou 

le SGML est qu’ils « décrivent l’information » au lieu de la présenter. Par la suite, il 

est facile de publier ou transformer un document XML en document PDF, HTML ou 

autre, selon les besoins. La séparation du contenu et de sa présentation est un facteur 

de productivité important parce qu’on simplifie la tâche de l’écriture, la ramenant au 

contenu seulement. 

La séparation du contenu et de sa présentation existe, en partie, dans le XHTML. Par 

exemple, quand on ajoute un élément de paragraphe « p », on fait un choix qui s’appuie 

sur la logique du texte, non sur son apparence. Quant aux choix des polices, de l’espace 

entre les lignes, de l’espace entre les paragraphes ou des couleurs, ils ne sont généralement 

pas pris en compte par le XHTML. Mais tout n’est pas parfait; l’utilisation de 

balises pour appeler de l’italique, soit « i » en XHTML, ne nous assure pas une séparation 

complète entre la présentation et le contenu. Par exemple, il serait plus « logique » 

d’indiquer qu’un mot appartient à une langue étrangère et qu’il apparaisse dès lors en 

italique. Ainsi, au lieu d’écrire « La vie est cool. », on aimerait écrire « La vie 

est cool. » ou quelque chose de similaire. Le XHTML constitue 

donc un compromis entre une séparation complète du contenu et de sa présentation, et 

l’absence de séparation. 

CC BY-NC-SA


Comme nous le verrons dans le troisième module, la façon la plus naturelle de dicter 

la présentation d’un document XHTML est d’utiliser un ou plusieurs fichiers CSS. 

En plaçant les instructions de formatage dans des fichiers CSS, distincts des fichiers 

XHTML, on obtient une bonne séparation du contenu et de sa présentation. Cette approche 

a un grand avantage : si on doit changer l’apparence d’un site web, on peut se 

contenter d’éditer quelques fichiers CSS au lieu de modifier le contenu lui-même qui 

se trouve dans plusieurs fichiers XHTML. Par exemple, si on veut que le texte contenu 

dans les tableaux soit en caractères gras et que le texte des listes apparaisse en rouge, 

on utilisera les instructions CSS suivantes : 

td {font-weight:bold;} 

li {color:red;} 

Le XML est aussi très utile pour aider à l’autodescription des informations. Par 

exemple, si dans un texte vous mettez tous les termes techniques en italique, il est 

possible que vous puissiez plus tard faire une recherche dans votre document pour 

tous les termes techniques. Toutefois, quelqu’un qui ne connaîtrait pas votre convention 

pourrait avoir beaucoup de mal à faire la même recherche. Par contre, si vous 

utilisez un élément particulier pour les termes techniques comme les balises , 

il devient beaucoup plus facile à quelqu’un d’autre de s’y retrouver 

dans votre document. On pourrait objecter que l’ajout de nombreuses balises alourdira 

le texte qui occupera alors trop de place sur le disque; l’expérience montre que la 

pérennité des documents doit presque toujours être privilégiée par rapport à l’utilisation 

de l’espace disque. 

En outre, le XML est un format ouvert : on peut utiliser une multitude d’outils différents 

pour manipuler les documents XML; nous ne sommes pas limités à des produits 

spécifiques à une compagnie ou institution donnée. Le XML a donc l’avantage sur 

plusieurs autres formats quant à sa pérennité. 

2.3.5 Le format DocBook 

Développé à partir de 1991, le format DocBook est un format de documents souvent 

utilisé pour la documentation technique. Le format DocBook est une application 

SGML qui devient une application XML. Il existe de nombreux outils permettant de 

transformer un document DocBook en document HTML ou PDF. 

Le format DocBook possède de nombreux avantages pour la rédaction de documents 

techniques parce qu’il assure une grande séparation entre le contenu et sa présentation : 

il ne permet que des balises ayant trait à la logique du texte; par exemple, il n’est pas 

possible de spécifier une police de caractères en DocBook. L’auteur peut alors concentrer 

son attention sur le contenu du document, sans perdre de temps avec le formatage, 

qui est une étape ultérieure. La séparation du contenu et de sa présentation permet aussi 

que plusieurs personnes puissent travailler sur un même projet de documentation tout 

en assurant une présentation uniforme, parce que DocBook ne comprend pas d’instructions 

de formatage. 

CC BY-NC-SA


Malheureusement, comme les autres formats hérités du SGML, plusieurs documents en 

format DocBook sont du SGML et non du XML; on ne peut donc pas utiliser les outils 

XML pour tous les documents DocBook. Par contre, la situation est en train de changer; 

il devient plus facile de déterminer si un document est bel et bien un document XML : 

la déclaration XML placée au début d’un document DocBook nous l’indique. 

Le format DocBook est fréquemment utilisé dans les projets de logiciels libres et « open 

source », ainsi que par certaines grandes sociétés, comme IBM. En général, les avantages 

du format DocBook sont plus visibles dans un contexte de travail d’équipe. 

La création d’un document DocBook simple n’est pas très difficile. Tout d’abord, bien 

qu’elle puisse varier selon les versions, la déclaration de type de document d’un document 

DocBook ressemble à ceci : 

 

Dans ce cas, on voit que le document DTD se trouve à l’adresse : 

http://www.oasis-open.org/docbook/xml/4.4CR2/docbookx.dtd 

Il faut cependant noter qu’il s’agit d’un document DTD qui dépend d’autres documents 

DTD et que la lecture d’un tel type de document DTD n’est pas très facile. 

L’élément-racine d’un document DocBook peut varier, mais les deux principales structures 

sont « book » (livre) et « article »; notez que l’on peut commencer par l’une ou 

l’autre : 

 

 

 

(...) 

 

 

 

 

(...) 

 

Ensuite, on doit ajouter un élément « bookinfo » ou « articleinfo », selon que le document 

est un livre ou un article. Le plus souvent, les éléments en question contiennent 

un élément « title » contenant le titre, ainsi qu’un élément « author » qui contiendra les 

éléments « firstname » (prénom) et « surname » (nom de famille). On peut aussi ajouter 

un élément « copyright » (droit d’auteur) qui contiendra un élément « year » (année) 

CC BY-NC-SA


et un élément « holder » (titulaire). Voici quelques structures courantes de documents 

DocBook : 

 

 

 

 

Notre documentation 

 

Alexis 

Letrotteur 

 

2004Bell Canada 

 

(...) 

 

 

 

 

 

Le sens de la vie 

 

Gilles 

Proulx 

 

2004 

Gouvernement du Canada 

 

 

(...) 

 

L’élément de base d’un document DocBook est l’élément « para » qui note la présence 

d’un paragraphe. Dans le cas d’un livre, on va le plus souvent faire suivre l’élément 

« bookinfo » d’éléments « chapter » (chapitre), qui eux-mêmes peuvent contenir des 

éléments « section », comme dans l’exemple qui suit : 

 

 

 

 


CC BY-NC-SA


 

Alexis 

Letrotteur 

 


 

 

Premier chapitre 

 

Première section du premier chapitre 

Mettre ici le premier paragraphe de la première section. 

 

 

 

Observez que tous les éléments « chapter », ainsi que tous les éléments « section » 

débutent par un élément « title » : c’est souvent suffisant. Il n’est pas permis de commencer 

un élément « section » ou « chapter » directement par un élément « para ». 

Par contre, on pourrait omettre d’avoir des sections dans nos chapitres, comme dans 

l’exemple qui suit : 

 

 

 

 


 

Alexis 

Letrotteur 

 


 

 

Premier chapitre 

Mettre ici le premier paragraphe du premier chapitre. 

 

 

Dans le cas d’un simple article, nous n’utiliserons pas les éléments « chapitre » et il 

suffit, le plus souvent, d’utiliser des éléments « section », comme dans l’exemple qui 

suit : 

 

 

CC BY-NC-SA


 

 


 

Alexis 

Letrotteur 

 


 

 

Première section de l’article 

Mettre ici le premier paragraphe de la première section. 

 

 

Deuxième section de l’article 

Mettre ici le premier paragraphe de la seconde section. 

 

 

On pourrait aussi utiliser les éléments « sect1 », « sect2 », « setc3 » et ainsi de suite, 

pour obtenir les notions de section, sous-section, sous-sous-section et ainsi de suite. 

Comme le format DocBook est destiné à la documentation technique, il existe plusieurs 

balises pour décrire le code informatique. L’élément le plus simple est l’élément 

« programlisting ». Ainsi, pour ajouter un petit programme Java dans un document 

DocBook, on utilisera l’élément suivant : 

 

public static void main(String[] arg) { 

System.out.println("Allo!"); 

} 

 

On peut également placer un élément « programlisting » dans les éléments « section », 

« chapter », « para », etc. 

Tout comme en HTML, on peut créer des listes avec les éléments « itemizedlist » 

(liste non ordonnée, équivalent de « ul » en HTML) et « orderedlist » (liste ordonnée, 

équivalent de « ol » en HTML). Une liste est constituée d’éléments « listitem » qui ne 

peuvent contenir directement du texte : on met généralement des éléments « para » dans 

les éléments « listitem ». Par contre, les éléments « listitem » ne peuvent apparaître hors 

des éléments « itemizedlist » et « orderedlist ». En outre, on place les listes dans les 

éléments « chapter », « section », etc. Voici quelques exemples : 

 

 

un triangle 

CC BY-NC-SA


 

 

un losange 

 

 

 

 

Premier élément (numéro 1) 

 

 

Second élément (numéro 2) 

 

 

Le format DocBook est supporté par certains traitement de textes comme OpenOffice 

qui est disponible gratuitement. 

2.3.6 L’ODF (Open Document Format) 

Historiquement, les formats de bureautiques ont été propriétaires, que ce soit le format 

WordPerfect ou le format Microsoft Word. Pour une institution, cela pose le problème 

de la pérennité des documents : qu’est-ce qui se produit si la compagnie qui propose 

un format décide de ne plus supporter un ancien format, parce qu’elle fait faillite ou 

change sa stratégie commerciale Qu’est-ce qui se produit si elle décide d’augmenter 

le coût de ses produits L’Open Document Format (ODF) est une norme XML adoptée 

en mai 2005 par OASIS et est devenu une norme ISO (ISO 26300.2006) le 30 novembre 

2006. Le format ODF est un format XML que tout le monde peut utiliser librement. 

Nous allons voir différentes techniques dans ce cours qui permettent de manipuler des 

documents XML et elles s’appliquent au format ODF. 

Le format ODF n’est pas très différent des nouveaux formats Open XML utilisés par 

Microsoft Office, mais au lieu de n’être soutenu que par une seule compagnie, ODF 

provient d’une entente entre plusieurs grandes sociétés : Adobe Systems, IBM, Intel, 

Novell et Sun Microsystems. Dans les deux cas (ODF et Open XML), les fichiers XML 

sont mis dans une archive compressée et nous avons accès à la sémantique des balises 

XML. Le logiciel OpenOffice utilise le format ODF et a les avantages d’être gratuit 

et disponible pour une variété de systèmes (Apple, Linux, Microsoft, etc.). Il est aussi 

possible de créer des documents ODF à partir de Microsoft Office 2007 à l’aide d’une 

composante logicielle supplémentaire (Open XML Translator). Dans le cadre de ce 

cours, vous pouvez remettre vos travaux dans le format ODF. 

CC BY-NC-SA



1. Quel énoncé décrit le mieux l’intention des créateurs du XML Choisissez la 


(a) Ils voulaient créer un format destiné aux programmeurs. 

(b) Ils voulaient créer un format de documents similaire au SGML ou au 

HTML. 

(c) Ils voulaient créer un format universel pour l’échange des données sur 

le web. 

2. Parmi les affirmations suivantes, lesquelles s’appliquent au XML Choisissez 


(a) Le XML aide à séparer le contenu d’un document de sa présentation. 

(b) Le XML encourage l’utilisation des formats propriétaires dans la création 

des documents comme Microsoft Word 97 ou PowerPoint 97. 

(c) Le XML permet de publier un même document dans plusieurs formats. 

3. Voici un exemple de document DocBook XML valable. Parmi les énoncés qui 

suivent, quels sont ceux qui s’appliquent à ce document 

 

 

]> 

 

 


 

&prenomduresponsable; 

&nomduresponsable; 

 

2004&prenomduresponsable; 

&nomduresponsable; 

 

 

Ceci est le premier chapitre de notre documentation. 

 

En cas de problème avec ce document, veuillez vous adresser à 

&prenomduresponsable; &nomduresponsable;. 

CC BY-NC-SA


Pour l’instant, il n’y a rien d’autre dans le document. 

 

 

 


(a) Dans ce document, il suffit de modifier le nom du responsable à un seul 

endroit et les changements s’appliqueront automatiquement dans tout le 

document. 

(b) Le document contient un chapitre et deux paragraphes. 

(c) Une fois publié dans un format comme HTML, PDF ou RTF, le lecteur 

verra un chapitre commençant par "Ceci est le premier chapitre" et se terminant 

avec "terminer ce document". 

4. Qu’est-ce qui ne va pas avec le document DocBook suivant 

 

 

 

Je suis certain que ce document est du XML valable! 

 


(a) Rien. Il s’agit d’un document valable. 

(b) Il y a une erreur dans la déclaration de type. 

(c) Il y a une erreur dans l’élément « para ». 

5. Parmi les énoncés suivants, quels sont ceux qui s’appliquent au format Doc- 

Book Choisissez toutes les réponses qui s’appliquent. 

(a) L’auteur d’un document DocBook se soucie uniquement du contenu et ne 

perd pas de temps à choisir des polices de caractères ou des couleurs pour 

son texte. 

(b) Si plusieurs personnes produisent la documentation pour un projet, il n’y a 

aucun problème à faire en sorte que la présentation soit uniforme, puisque 

le format DocBook ne contient aucune information touchant la présentation 

du texte. 

(c) Le format DocBook est du XML; on peut donc employer tous les outils 

XML sur tous les documents DocBook. 

CC BY-NC-SA


6. Votre société décide d’utiliser le XML comme format d’échange pour ses listes 

de numéros de série; elle pourra ainsi utiliser les outils XML et assurer la pérennité 

des documents. L’ingénieur en charge propose deux formats possibles. Quel 

format choisissez-vous Dites pourquoi. 

 

 

232-434 

333-434 

111-434 

444-555 

 

 

232-434 333-434 111-434 444-555 


(a) Le premier choix est préférable, car il n’y a qu’un seul numéro de série par 

ligne et le résultat est plus lisible. 

(b) Le second choix est préférable parce qu’il utilise moins d’espace. 

(c) Le premier choix est préférable parce qu’on peut voir tout de suite les numéros 

de série. 

7. Parmi les suivants, quels sont les documents DocBook valables Choisissez 


(a) 

 

 

 

 

 


 

Jean 

Bergeron 

 

2004UQ 

 

CC BY-NC-SA


 


 

 

Ceci est le premier point 

 

Ceci est le second point 

Ceci est le troisième point 

 

 

 

 

(b) 

 

 

 

 

 


 

Jean 

Bergeron 

 

2004UQ 

 

 


Voici un exemple de code Java: 

 



} 

 

 

 

(c) 

 

 

 

CC BY-NC-SA


 

 


 

Jean 

Bergeron 

 

2004UQ 

 

 

 



} 

 


 

 

(d) 

 

 

 

 

 


 

Jean 

Bergeron 

 

2004UQ 

 

 


Voici un exemple de code Java: 

 


if(arg.length


(e) 

 

 

 

 

 


 

Jean 

Bergeron 

 

2004UQ 

 

 


 

Ceci est le premier point 

Ceci est le second point 

 

 

 


1. (a) Bien que cela soit vrai en partie, leur but premier était de créer un format 

de documents simple et efficace. 


(c) Non. Leur but premier était de créer un format pour les documents. 

2. (a) (Bonne réponse) Effectivement, dans le contexte des documents XML, le 

XML sert le plus souvent à décrire le contenu du document plutôt que la 

façon dont il sera présenté. On utilise d’autres technologies, comme les 

technologies CSS ou XSLT pour la présentation. 

(b) Non. Le XML n’encourage pas les formats propriétaires pour les documents; 

il encourage plutôt l’utilisation d’applications XML qui agissent 

comme des normes acceptées par des communautés. 

(c) (Bonne réponse) Généralement, la version XML originale n’est pas destinée 

à être lue par les humains; on s’attend plutôt à ce que le document XML 

soit transformé ou publié dans un format pratique pour la lecture. 

CC BY-NC-SA


3. (a) (Bonne réponse) Effectivement, la DTD interne contient deux déclarations 

d’entités qui nous permettent d’éviter de recopier partout le nom du responsable. 

On ne risque donc pas de commettre des erreurs si jamais on devait 

changer ce nom. 

(b) (Bonne réponse) Effectivement, la structure du document est claire. 

(c) Non, la phrase "Il faudrait bien que je me dépêche à terminer ce document." 

est un commentaire XML et ne sera normalement pas incluse dans 

la version destinée à la consommation par des humains. 

4. (a) Non. La déclaration de type déclare l’élément-racine « book », alors que 

l’élément-racine est « para ». 

(b) (Bonne réponse) Effectivement, il faudrait avoir

XML sur le web 155 

2.4 XML sur le web 


Comprendre le XHTML pour publier des documents sur le web. 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation. 

2.4.3 Le XHTML et le web 

Rappelons d’abord que le XHTML est un format hybride : il tient à la fois du HTML 

et du XML. Nous allons étudier ce format, examiner son importance et son rôle pour 

la publication de documents sur le web. 

Produire du XHTML est une des principales façons de publier du XML sur le web. Le 

XHTML en question peut être produit à la main avec un éditeur de texte : dans ce cas, 

il faudra s’assurer qu’il est bien formé. Avec un navigateur comme Mozilla Firefox, on 

peut s’en assurer en l’enregistrant avec un nom portant l’extension « .xhtml », comme 

« mon_fichier.xhtml », et en l’ouvrant avec le navigateur. On peut aussi produire du 

XHTML en « transformant un fichier XML », ce que nous verrons dans le prochain 

module. Finalement, on utilise aussi beaucoup de XML sur le web sans passer par le 

XHTML, soit en utilisant la technologie CSS, que nous étudierons dans le prochain 

module, soit en destinant le XML aux machines. 

L’avantage du XHTML est de pouvoir bénéficier de toute la puissance du XML, 

de toutes les astuces et outils que l’on connaît en XML, tout en conservant le format 

HTML qui s’est montré utile au fil des ans. 

On peut se demander alors pourquoi le HTML ne suffit pas. Après tout, le web s’est 

fait avec le HTML et ça fonctionne bien. L’embarras avec le HTML, c’est qu’il permet 

de faire des choses que les machines ne savent pas bien traiter. Par exemple, prenons le 

document HTML typique suivant : 

 

 


Il est beau, non 

 

 

Cet exemple n’est pas un document XML valable! On voit bien qu’il s’agit d’un document 

avec deux paragraphes (balises « p »), dont une partie est en caractères gras 

CC BY-NC-SA


(balise « b ») et une autre en italique (« i »). On peut toutefois se demander, à juste 

titre, si la phrase « Il est beau, non » est en italique ou pas. 

Il y a deux façons de rendre ce document HTML en XHTML : 

 

 

 

 

le titre est obligatoire en XHTML 

 

 



 

 

ou encore 

 

 

 

 

le titre est obligatoire en XHTML 

 

 



 

 

On constate aisément que le XHTML ne tolère pas les ambiguïtés qui rendent le HTML 

difficile à traiter par les machines. C’est un avantage de taille, car il existe plusieurs 

outils gratuits pour traiter le XML et qui peuvent être utilisés avec le XHTML, alors 

que les outils pour traiter le HTML sont plus difficiles à développer et, en général, plus 

capricieux parce qu’ils doivent traiter des ambiguïtés. 

Le XHTML permet aussi de faire des choses qui n’existent pas en HTML. Par exemple, 

on peut utiliser des appels d’entités. Supposons que le nom d’un auteur ou le titre 

de son livre apparaissent à plusieurs reprises dans un document. La redondance de 

l’information peut être une source d’erreur : si on change le titre du livre à un endroit, 

il faut le changer partout. Avec le XHTML, on peut déclarer les entités suivantes : 

 

CC BY-NC-SA


 

Ensuite, on pourra avoir le document suivant : 

 

 

]> 

 

 

&titre; 

 

 

Le titre de ce livre est: &titre;. L’auteur est &monnom;. 

Copyright 2010, par &monnom;. 

 

 

Le résultat à l’écran, dans un navigateur qui comprend le XHTML, sera : 

Le titre de ce livre est: Le père de tous les documents. 

L’auteur est Daniel Lemire. 

Copyright 2010, par Daniel Lemire. 


1. Parmi les documents suivants, lesquels sont du XHTML valable 


(a) 

 

 

 

Un titre 

 

 

Voici mon document 

 

 

CC BY-NC-SA


(b) 

 

 

 

Un titre 

 

 

Voici mon document 

 

 

(c) 

 

]> 

 

 

Un titre 

 

 

&texte; 

 

 

(d) 

 

]> 

 

 

Un titre 

 

 

&texte; 

 

 

(e) 

 

 

CC BY-NC-SA


 

Un titre 

 

 

 

 

 

2. Quel énoncé décrit le mieux le XHTML 


(a) Un document XHTML est du XML bien formé. 

(b) Le document XHTML devrait être du XML bien formé, mais le 

navigateur va tolérer de petites erreurs comme des balises croisées 

test. 

(c) Le XHTML est une nouvelle technologie qui exige un investissement important 

et une conversion coûteuse des documents. 

3. Par rapport au XHTML, les énoncés suivants sont-ils justes 


(a) Si mon entreprise utilise déjà beaucoup le XML, le XHTML est un choix 

plus facile. 

(b) Les navigateurs ne supportent pas encore XHTML. 

(c) Le XHTML est une technologie favorisant la pérennité des documents. 

4. Quels énoncés, parmi les suivants, décrivent bien le XHTML dans le contexte du 

XML 


(a) On peut utiliser les balises XHTML dans nos propres DTD. 

(b) On peut utiliser nos propres balises en XHTML. 

(c) On peut définir ses propres entités en XHTML. 

5. Parmi les énoncés suivants, lesquels s’appliquent à un document XHTML Choisissez 


(a) Il s’agit d’un document HTML pouvant s’afficher dans un navigateur. 

(b) Il s’agit d’un document XML bien formé. 

(c) Il s’agit d’un document XML valable. 

6. Combien de paragraphes compte le document XHTML suivant 

CC BY-NC-SA


 

 

 

 


 

 

L’enfant pleure dans la rue. Subitement, le Soleil se lève. 

Ah! Que la vie est belle! 

 

 


(a) 1 

(b) 2 

(c) 3 


7. Combien de paragraphes compte le document XHTML suivant 

 

 

 

 


 

 

L’enfant pleure dans la rue. 

Subitement, le Soleil se lève. 

Ah! Que la vie est belle! 

 

 


(a) 1 

(b) 2 

(c) 3 


CC BY-NC-SA


8. Combien de lignes horizontales sont représentées par ce document XHTML 

 

 

 

 


 

 

 

 

 

 


(a) 1 

(b) 2 

(c) 3 


9. Comment représente-t-on une liste numérotée en XHTML 


(a) 

 

 

 


 

 

 

élément 

élément 

 

 

 

(b) 

 

 

 

CC BY-NC-SA



 

 

 

élément 

élément 

 

 

 

(c) 

 

 

 


 

 

 

élément 

élément 

 

 

 

(d) 

 

 

 


 

 

 

élément 

élément 

 

 

 

CC BY-NC-SA



1. (a) Non. La balise « p » doit être fermée. 

(b) Non. La balise « P » n’existe pas en XHTML : le XML tient compte de la 

casse et l’élément « p » n’est pas la même chose que l’élément « P ». 

(c) (Bonne réponse) Oui. L’entité contient deux éléments bien formés et le 

résultat est du XHTML valable. 

(d) Non. Une entité doit être du XML bien formé et si une entité contient des 

balises, il doit s’agir d’éléments avec balise ouvrante et balise fermante. 

(e) Non, les attributs doivent être entre guillemets comme ceci : 

 

 

 

 

Un titre 

 

 

 

 

 

2. (a) (Bonne réponse) Effectivement. Du XHTML doit absolument être bien 

formé. 

(b) Justement pas : on ne tolère pas de telles erreurs en XHTML, car cela rend 

la vie plus difficile aux machines et mène à des problèmes de compatibilité 

entre les navigateurs. 

(c) Non. Le XHTML est très similaire au HTML. 

3. (a) (Bonne réponse) Effectivement. On peut facilement transformer le XML 

en XHTML et si vous connaissez les outils XML, vous pouvez les utiliser 

avec le XHTML. 

(b) C’est faux. La plupart des navigateurs supportent bien le XHTML, mais 

tous ne supportent pas l’ensemble des normes XML. 

(c) (Bonne réponse) Effectivement. Comme le XHTML suit une DTD fixe, il 

sera possible dans le futur de bien interpréter les documents XHTML, alors 

que le HTML que l’on trouve sur le web est souvent désuet après quelques 

mises à jour des navigateurs. 

4. (a) (Bonne réponse) C’est sans problème. On peut recopier les parties des DTD 

XHTML et les utiliser dans nos propres DTD. Cela peut être utile si un 

document XML doit être transformé en XHTML plus tard. 

CC BY-NC-SA


(b) Pas si nous utilisons les DTD officielles. Si nous écrivons vos propres DTD, 

il est possible que notre navigateur ne reconnaisse pas le contenu comme 

étant du XHTML. 

(c) (Bonne réponse) Effectivement. Nous avons vu plus haut que les entités 

pouvaient être utilisées pour marquer le titre d’un livre ou le nom d’un 

auteur, mais on peut aussi définir des entités pour obtenir des caractères 

spéciaux, et ainsi de suite. 

5. (a) (Bonne réponse) Oui. D’ailleurs, le texte d’introduction à HTML en est un 

exemple. 


(c) (Bonne réponse) Effectivement, avec une déclaration de type de document 

utilisant un identifiant public. 


(b) Non. 

(c) Non. 

(d) Non. 

7. (a) Non. Il ne s’agit pas de XHTML valable; la balise est incorrecte. 

(b) Ce serait vrai s’il s’agissait de XHTML valable. 

(c) Non. 

(d) (Bonne réponse) Effectivement. Il ne s’agit pas de XHTML valable, la seconde 

balise paragraphe se terminant par . Un logiciel compatible avec 

XHTML comme Firefoxpeut très bien ne rien afficher à l’écran. 

8. (a) Non. 


(c) Non. 

(d) Non. 

9. (a) Non. Ce n’est pas du XHTML valable. 

(b) Non, ce n’est pas du XHTML valable. 


(d) Non. C’est bien du XHTML valable, mais la liste n’est pas numérotée. 




Il contribue à l’évaluation de l’objectif suivant : 

CC BY-NC-SA



informations. 

Ce travail consiste à discuter d’un sujet avec les autres étudiants du cours et à réunir 

vos textes dans un compte rendu. 


Avant d’entreprendre ce travail noté, il est recommandé d’avoir terminé les activités 

d’autoévaluation du module 1 et d’avoir commencé l’étude du module 2. Vous avez 

jusqu’à la fin du cours pour réaliser ce travail. 

Vous devez contribuer au forum de façon originale et substantielle. 

1. Choisissez un sujet qui vous intéresse; quelques pistes de discussion vous sont 

suggérées plus loin. 

2. Effectuez des recherches sur le web, prenez des notes. 

3. Inscrivez-vous sur Facebook si ce n’est pas déjà fait (http://fr-fr.facebook.com/). 

Facebook est un site de réseautage social. L’inscription sur Facebook est gratuite 

et elle ne prend que quelques minutes. Par contre, n’allez pas demander de l’aide 

aux services de l’Université pour vous brancher à Facebook : demandez plutôt à 

votre tuteur de vous aider. 

4. Accédez au groupe du cours « INF 6450 » à l’adresse http://www.facebook.com/ 

group.phpgid=57220667716. Vous trouverez au sein de la page du groupe un 

forum de discussion. 

5. Rédigez votre intervention de façon claire et précise afin d’inciter les lecteurs à 

vous lire et à commenter; prenez soin de préciser vos références. 

6. Lisez les messages de vos collègues et échangez. Répondez à vos interlocuteurs 

et réagissez à leur contribution. 

7. Quand vous jugerez votre participation suffisante, que aurez terminé votre discussion, 

réunissez les textes que vous avez produits. 

8. Rédigez un compte rendu de votre participation (Word 97/2000/XP, ODF, PDF, 

RTF ou au format texte) qui doit contenir une copie des textes que vous avez 

produits dans le forum ou blogue. 

9. Transmettez à votre personne tutrice, par courriel, votre compte rendu clairement 

identifié à votre nom, en le joignant au message en fichier attaché. L’objet 

de votre courriel doit commencer par « [INF6450][TRAVAIL2] »; dans le 

message, indiquez votre nom, votre numéro d’étudiant (8 chiffres), la date 

de remise de votre travail et le nom de votre personne tutrice, ainsi que les 

mentions « Travail noté 2 » et « INF 6450 ». Ne transmettez pas plusieurs 

fichiers. Ne transmettez pas une archive compressée (zip ou autre). 

CC BY-NC-SA


En cas de panne 

Il peut arriver que vous ne puissiez vous brancher au groupe Facebook du cours. En 

effet, Facebook peut tomber en panne, vous refuser l’accès ou même cessez d’exister. 

Comme alternative, vous pouvez aussi commenter sur le blogue du cours. 

Pistes de discussion 

Bien que votre contribution doive être originale et que nous vous invitions fortement 

à faire une recherche préalable sur le web pour nourrir vos discussions, vous pouvez 

utiliser les pistes suivantes : 

– Le blogue du cours à http://www.daniel-lemire.com/blogue/category/xml/ est régulièrement 

mis à jour. 

– Le Security Assertion Markup Language (SAML) doit permettre d’identifier et d’autoriser 

les utilisateurs sur plusieurs sites en ne leur demandant qu’une seule fois leur 

mot de passe. 

– La langage RuleML permet d’écrire des règles formelles en XML et de les échanger 

entre divers sites. 

– Les versions récentes de Microsoft Office utilisent de façon agressive le XML 

comme format de documents. On trouve sur le web plusieurs articles traitant de cette 

question, dont un article sur les conséquences de l’utilisation de XML par Microsoft 

pour les logiciels antivirus et un article sur les conséquences légales des choix faits 

par Microsoft. 

– Le clone gratuit de Microsoft Office, OpenOffice (voir openoffice.org) utilise lui 

aussi un format XML pour ses documents. De plus, il est possible de trouver sur 

le web plusieurs articles portant sur l’utilisation du XML faite par OpenOffice. 

– Le jeu vidéo très populaire World of Warcraft offre un outil à base de XML permettant 

de modifier l’interface du jeu. 

– Le W3C a récemment publié les spécifications de VoiceXML 2.0 avec une annonce 

en français; de plus, le magazine Silicon a publié un article sur le sujet. En principe, 

VoiceXML devrait permettre de créer des systèmes contrôlés par la parole : par 

exemple, un outil de gestion de l’inventaire par téléphone qui permettrait de demander 

un rapport des stocks à partir d’un numéro de série. 

– On a appris récemment que le gouvernement américain rend disponibles les données 

météorologiques au format XML. 

2.5.3 Critères de correction et de notation 

L’évaluation porte sur l’originalité de votre propos, sur l’ampleur de la recherche sousjacente 

à votre discussion et sur la qualité des textes que vous proposez. 

– Originalité : Est-ce que votre contribution diffère de ce qu’on trouve déjà dans le 

forum ou sur le blogue (30 %) 

CC BY-NC-SA


– Contenu et recherche : Est-ce que votre contribution démontre une recherche substantielle 

sur le sujet Est-ce que vous avez donné 3 ou 4 références (comme des 

URL) pertinentes et originales (60 %) 

– Présentation : Est-ce que votre contribution est faite de textes lisibles, clairs, cohérents, 

écrits dans un français correct (10 %) 


2.6.1 Objectifs, pondération et critères de correction 


Il contribue à l’évaluation des objectifs suivants : 

– Utiliser un « vocabulaire » ou une application XML pour présenter des informations 

en format XML. 



informations. 

Votre travail sera noté en utilisant les critères suivants : 

– votre capacité à créer un document DocBook valable et bien formé (30 %), 

– votre utilisation des balises requises (15 %), 

– l’utilisation d’une instruction spéciale (XSLT) (5 %) 

– production d’un document XHTML valable selon les consignes (20 %). 

– le contenu de votre texte (clarté, cohérence, qualité du français) (30 %). 

Il est recommandé d’avoir terminé les activités d’autoévaluation des modules 1 et 2 

avant d’entreprendre ce travail noté. Pour réaliser ce travail, vous devez utiliser la technologie 

XSLT (sans nécessairement la maîtriser); vous pouvez également commencer 

les autres modules avant de le terminer si vous jugez que votre connaissance du XML 

n’est pas encore suffisante. Vous avez jusqu’à la fin du cours pour réaliser ce travail. 

2.6.2 Description du travail 

En respectant les consignes spécifiques qui suivent, vous rédigerez un texte qui répondra 

à la question suivante : « Pourquoi est-ce que je devrais utiliser XML dans mon 

projet ». Vous fournirez au minimum 6 bonnes raisons justifiant l’utilisation de XML 

au sein d’un projet stratégique. 

Votre texte, que vous nommerez « INF6450travail3_votrenom.xml », sera un document 

DocBook d’au moins 2000 mots (environ 130 lignes), comptant au moins deux 

« chapitres » (éléments « chapter »), chacun comptant au minimum 2 sections. 

CC BY-NC-SA


En outre, vous devez produire un document XHTML valable qui résume 

brièvement vos 6 arguments. Le document XHTML doit être nommé 

« INF6450travail3_votrenom.xhtml » et doit être du XHTML valable. Votre document 

doit utiliser au moins un élément « acronym », un élément « samp », et un 

élément « blockquote ». 

Transmettez les deux documents à votre tuteur par courriel en tant que fichiers attachés. 




« Travail noté 3 » et « INF 6450 ». Ne transmettez pas une archive compressée (zip 

ou autre). 

Ce travail de rédaction est personnel et votre texte doit être original. 

Rappelons que lorsqu’on vous donne le contenu d’un document XML, vous devez 

supposer que le document débute avec le premier caractère et se termine avec le dernier. 


1. Un document DocBook débute normalement par la définition de type de document 

(DTD) : 

 

Cependant, il suffit de visiter l’URL 

http://www.oasis-open.org/docbook/xml/4.4CR2/docbookx.dtd 

pour se rendre compte que le document DTD de DocBook n’est pas trivial : il 

comporte un grand nombre d’éléments dont nous n’avons pas besoin. En particulier, 

DocBook a plusieurs balises pour la description du code source informatique. 

Utilisez donc un document DTD nommé « simpledocbook.dtd », une version 

grandement simplifiée de DocBook et ayant le contenu suivant : 

 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA


 

 

 

 

 

 

2. Placez ce document DTD dans le même répertoire que votre document 

XML. 

3. Rédigez le texte de votre document DocBook en utilisant au moins une fois 

tous les éléments de cette DTD, y compris « programlisting » et « listitem ». 

Votre déclaration de type de document doit être : 

 

Même si, à strictement parler, un élément « programlisting » doit contenir le 

texte d’un programme, aux fins de ce travail noté, vous pouvez utiliser du XML 

dans cet élément. 

Note. Votre document ne sera pas un véritable document DocBook, car il n’aura 

pas une déclaration normale de type de document. Cependant, il vous serait possible 

de remplacer la déclaration de type de document par une déclaration normale 

et vous auriez alors un véritable document DocBook. 

4. Un document DocBook ne contient pas les informations de formatage et, en 

général, n’est pas très lisible. Pour permettre une lecture plus aisée du document, 

utilisez le document XSLT qui se trouve à l’annexe 1, plus loin. Copiez le 

document en question et enregistrez-le sous le nom « docbook.xml », dans le 

même répertoire que votre document XML. Le XSLT permet de transformer 

le document DocBook en HTML. On ne vous demande pas de comprendre le 

XSLT, car le sujet sera étudié dans le prochain module. 

5. Pour l’instant, ajoutez simplement l’instruction suivante dans votre document 

XML, immédiatement après la déclaration XML 

 

6. Ensuite, une fois votre document XML terminé, ouvrez-le dans Firefox; vous 

devriez voir votre document nouvellement formaté. Assurez-vous que le document 

« docbook.xml » de l’annexe 1 est bien dans le même répertoire que votre 

document DocBook. 

Constatez alors comment votre document XML est présenté de façon totalement 

différente de son allure originale. C’est un résultat de la division entre le contenu 

et sa présentation : le fichier XSLT s’occupe ici de la présentation, alors que 

votre texte XML ne comporte que le contenu. Par exemple, la version formatée 

dispose d’une table des matières qui se génère automatiquement, alors que le 

document XML n’a aucune notion de table des matières. 

7. La production du document XHTML se fait de manière similaire, mais sans 

l’utilisation d’un document XSLT. Pour tester la validité de votre document, 

CC BY-NC-SA


vous pouvez utiliser l’outil de validation du W3C disponible à l’adresse 

« http://validator.w3.org/ » (voir « Validate by File Upload »). 

8. Transmettez à votre personne tutrice, par courriel, vos documents XML clairement 

identifiés à votre nom, en les joignant au message. Vous devez transmettre 

deux documents XML : un document DocBook et son résumé en XHTML. Dans 

la zone « Objet », inscrivez le sigle du cours et le numéro du travail (INF 6450 - 

Travail noté 3) dans le message, indiquez votre nom, votre numéro d’étudiant (8 

chiffres), la date de remise de votre travail et le nom de votre personne tutrice, 

ainsi que les mentions « INF 6450 » et « Travail noté 3 ». 

Annexe 1. Document XSLT 

Le document XSLT suivant servira à convertir votre document DocBook en HTML. 

C’est là un avantage du format DocBook : on peut facilement le convertir en d’autres 

formats. Nous étudierons le XSLT dans le troisième module. 

 

 

 

 

 

 

 

 

 

 

© 

Table des matières 

 

 

 

 

 

 

par 

 

 

 

 

 

. 

 

CC BY-NC-SA


 

 

 

 

. 

 

 

 

 

Chapitre 

. 

 

 

 

 

 

 

. 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA


 

 

 

 

 

 

 

CC BY-NC-SA

Module 3 : Technologies XML 

3.1 Aperçu 


Nous avons vu que le XML permet de stocker et d’échanger des informations et que 

certaines formes de XML, comme le XHTML, s’affichent de façon lisible dans un navigateur. 

Cependant, dans une organisation, il faut souvent pouvoir afficher de façon 

lisible du XML qui n’est pas nécessairement compris par un navigateur. Dans ce module, 

nous présentons deux technologies importantes qui solutionnent cette situation : 

XSLT et CSS. Nous verrons aussi que le XSLT permet de transformer automatiquement 

le XML en d’autres formats, ce qui peut être très utile. 

L’objectif spécifique du module est : 

– Interpréter des fichiers XML utilisant des espaces de noms, des transformations 

XSLT ou des instructions CSS. 

Une activité, le travail noté 4, nous permettra d’évaluer votre atteinte de cet objectif. 


Il n’est pas nécessaire de terminer l’étude de ce module avant de passer aux autres 

modules du cours. 

Nous vous invitons à procéder à l’étude de ce module dans l’ordre suivant : 

– XSLT, XPath, XQuery, XPointer et XLink 

– CSS 

Lisez les textes et vérifiez vos connaissances en répondant aux deux questionnaires 

d’autoévaluation; réalisez ensuite le travail noté 4 qui prend la forme d’un questionnaire 

portant sur XSLT et CSS. 

173


Le pense-bête pour le XSLT, en annexe dans la version imprimée du cours, rassemble 

les principaux éléments du XSLT et précise leur fonction. 

3.2 XSLT 


Comprendre le XSLT comme application XML pour transformer les documents, grâce 

aux feuilles de style. 



sur le langage XSL (Extensible Stylesheet Language), mais en particulier sur les XSL 

Transformations (XSLT). On traitera également des chemins XPath et de XQuery. 

3.2.3 Un regard critique 

Le XML n’est pas un langage de programmation. Néanmoins, on peut utiliser le XML 

pour définir un langage comme le XSL. Est-ce que c’est une bonne idée Plusieurs 

auteurs, dont Alan Holub, croient que le XML est une syntaxe trop lourde pour la 

programmation. 

XML is perhaps the worst programming language ever conceived. I’m 

not talking about XML as a data-description language, which was its original 

design. I’m talking about perverting XML for programming applications. 

It’s inappropriate to use XML as a scripting language (...). These 

sorts of XML "programs" are unreadable, unmaintainable, an order of magnitude 

larger than necessary, and audaciously inefficient at runtime. (Alan 

Holub, Software Development Times, September 2006) 

Personnellement, je trouve que le XSLT est amusant et utile. Il est utilisé par des millions 

de sites web et on ne peut prétendre être un expert en XML sans une bonne 

maîtrise du XSLT. 

3.2.4 Les machines de Turing et la technologie XML 

Une machine de Turing est un modèle abstrait qui sert à représenter les ordinateurs. 

La thèse de Church-Turing affirme que tout traitement d’information peut être accompli 

par une machine de Turing. On accepte généralement cette hypothèse comme étant 

CC BY-NC-SA

XSLT 175 

vraie en informatique. Un langage de programmation est Turing-complet s’il peut effectuer 

tous les calculs qu’une machine de Turing peut faire. Le Java, le XSLT et 

XQuery sont des langages qui sont Turing-complet. Tous les langages informatiques 

ne sont pas Turing-complet : CSS ne l’est pas. 

3.2.5 Qu’est-ce que le XSLT 

La première version du langage XSLT (Extensible Stylesheet Language Transformation) 

a été publiée en 1997 et elle est devenue une recommandation W3C en 1999. Elle 

fait partie du XSL (Extensible Stylesheet Language) qui comprend une seconde composante, 

les XSL-FO (Extensible Stylesheet Language Formatting Objects). La technologie 

XSL tire son origine du besoin d’un langage simple, mais suffisamment puissant 

pour pouvoir contrôler finement l’affichage du XML. On utilise beaucoup le XSLT sur 

le web et au sein des systèmes d’information, alors que le XSL-FO est davantage utile 

pour les applications de mise en page spécialisées. Dans ce cours, nous nous soucierons 

seulement du XSLT, dont l’utilité dépasse de loin les problèmes de présentation. 

L’objectif poursuivi par le XSLT est de transformer les documents XML en d’autres 

documents. Par exemple, supposons que vous ayez le document suivant : 

 

 

10.10 

Jean Rochond 

Achat d’ordinateur 

 

et que vous vouliez transformer ce type de document XML en document HTML qui 

aurait la forme suivante : 

 

 

Facture de Jean Rochond 

 

Ceci est une facture pour Jean Rochond de 10.10$ 

pour: Achat d’ordinateur. 

 

Si votre entreprise utilise du XML et que vous désirez envoyer des factures par courriel, 

vous pourriez envoyer le document HTML au lieu du document XML. De cette 

manière, le client pourrait consulter sa facture sans avoir à comprendre le XML. 

On pourrait bien sûr écrire un programme en Java qui effectuerait cette opération, mais 

la conception d’un programme Java prend du temps et on cherche parfois une solution 

plus économique, plus rapide. Avec l’exemple que nous venons de voir, on pourrait 

CC BY-NC-SA


automatiser la transformation de XML en HTML en moins d’une quinzaine de minutes. 

Pour obtenir le résultat désiré, il faut utiliser un petit fichier XSLT. 

3.2.6 Les langages déclaratifs 

Un langage comme Java est orienté objet et procédural. Ce n’est pas, par contre, un 

langage déclaratif et on dit donc qu’il est impératif. Les langages déclaratifs sont des 

langages qui définissent le problème au lieu d’en définir la solution. On les reconnaît 

souvent parce qu’ils énoncent des règles au lieu d’énoncer des procédures. 

Le langage Prolog est un exemple de langage déclaratif parce que le programmeur 

ne fait que saisir des relations sans définir comment l’ordinateur doit combiner ses 

relations: 

pere(X,Y) :- parent(X,Y),homme(X). 

freresoeur(X,Y) :- parent(Z,X), parent(Z,Y). 

Le SQL est aussi déclaratif parce qu’on spécifie à l’ordinateur quelles informations on 

veut sans pour autant spécifier comment l’information doit être trouvée: 

SELECT age FROM table WHERE age > 25; 

Le XSLT et XQuery sont des exemples plus récents de langages déclaratifs. On affirme 

souvent que les langages déclaratifs sont plus lents que les langages impératifs 

parce que le logiciel doit lui-même trouver la meilleure stratégie pour évaluer le programme 

sans recevoir beaucoup d’indices de la part de l’humain. Le contraire peut 

aussi être vrai: comme le logiciel peut optimiser à sa guise l’exécution du programme 

étant donné l’absence de structure imposée par l’humain, il est possible pour un langage 

déclaratif de surpasser en vitesse un langage impératif. En pratique, personne ne 

se plaint vraiment de la lenteur relative du XSLT, de SQL ou de Prolog. Cependant, 

pour le programmeur habitué à la programmation impérative, la programmation déclarative 

peut être source de confusion. Avec l’expérience, on se rend compte que, pour 

bien des problèmes, la programmation déclarative est préférable surtout lorsqu’on ne 

veut pas se soucier des détails techniques comme la façon dont le fichier XML est lu et 

comment il est stocké en mémoire. 

Le XSLT (et XQuery) peut aussi être considéré comme un langage fonctionnel (voir 

FXSL ou The Functional Programming Language XSLT - A proof through examples 

par Dimitre Navatchev) au même titre que APL, Lisp, Haskell, Maple, Mathematica, 

Ocaml ou Scheme. 

3.2.7 Les fichiers XSLT 

Le fichier XSLT contient des règles qu’un « processeur XSLT » applique aux fichiers 

XML pour les transformer. Heureusement, si vous utilisez Firefox, vous avez déjà un 

CC BY-NC-SA

XSLT 177 

processeur XSLT moderne à même votre navigateur. Lors de l’ouverture d’un document 

XML, Firefox tente automatiquement de trouver et d’exécuter un document XSLT 

pour transformer le document XML. 

Un processeur XSLT va parcourir tous les éléments de votre document en commençant 

par l’élément-racine et, à chaque fois, il va tenter d’appliquer une règle. 

Commençons par créer le fichier XSLT suivant qu’on enregistrera sur le disque comme 

étant « xslt.xml » : 

 

 

 

Ce fichier ne contient aucune « règle » et constitue le document XSLT de base. Nous 

vous suggérons de faire l’exercice de création de ce document avec Bloc-notes, par 

exemple. 

Un fichier XSLT est un document XML bien formé, utilisant l’espace de noms 

« http://www.w3.org/1999/XSL/Transform » et ayant pour élément-racine stylesheet 

(ou transform), lequel a lui-même un attribut « version ». On ne discute ici que de 

la première version de XSLT (1.0); on utilise donc 1.0 comme valeur d’attribut pour 

version. 

Prenons maintenant le fichier XML que nous avions auparavant; modifions-le un peu 

en le faisant pointer vers le fichier XSLT nouvellement créé : 

 

 

 

10.10 

Jean Rochond 


 

On ajoute donc la ligne : « ». Cette ligne indique au navigateur, ou à un autre logiciel, 

que le document XML peut être transformé par le fichier XSLT nommé 

« xslt.xml ». Le chemin peut être relatif ou absolu : on pourrait donc aussi avoir une 

ligne comme : 

«» 

si l’URL « http://www.mondomaine.com/xslt.xml » pointe vers un fichier XSLT. 

CC BY-NC-SA


Il suffit d’enregistrer ce nouveau document XML dans le même répertoire que le fichier 

« xslt.xml », disons avec le nom « test.xml », puis d’ouvrir le fichier « test.xml » dans 

Firefox. Normalement, on ne devrait rien voir à l’écran (une page vide), car le document 

XSLT utilisé est vide de toute instruction et le résultat ne sera pas du HTML. 

Le résultat peut cependant varier selon le navigateur utilisé, car votre navigateur pourrait 

afficher le texte, même s’il ne s’agit pas de HTML : dans ce cas, vous ne verriez 

que le texte contenu dans le document XML, les balises en moins. Vous pouvez tester 

vos scripts XSLT en ligne directement sur la page web http://www.daniel-lemire.com/ 

blogue/xsltprocessor.html. Avec ce dernier outil, écrit en ECMAScript, il n’est pas nécessaire 

d’avoir une instruction xml-stylesheet : on peut traiter n’importe quel fichier 

XML avec n’importe quelle transformation XSLT. En ce sens, on peut programmer en 

XSLT sans jamais utiliser l’instruction xml-stylesheet. 

3.2.8 « Éléments xsl:template » 

Modifions maintenant le fichier « xslt.xml » de façon à rendre l’expérience plus intéressante. 

Tout d’abord, traitons tous les éléments « facture » du document XML. Pour 

obtenir le résultat, il faut placer un élément « » dans 

l’élément-racine du document XSLT comme ceci : 

 

 

 

On doit mettre quelque chose ici!!! 

 

 

Il faut voir l’élément « xsl:template » comme une règle qui dit : à chaque fois qu’on 

rencontre un élément qui s’appelle « facture », faisons ceci. Le modèle est inclus dans 

l’élément « xsl:template ». Dans l’exemple de document XSLT que nous venons de 

voir, le processeur XSLT remplacerait tous les éléments « facture » qu’il rencontre par 

le texte « On doit mettre quelque chose ici!!! », ce qui donnerait comme résultat le 

fichier suivant (le résultat exact peut varier un peu selon le processeur XSLT) : 

 


Malheureusement, ce n’est pas du HTML valable et Firefox devrait n’afficher qu’un 

écran vide si vous tentez d’ouvrir le fichier « test.xml » avec un lien vers un tel fichier 

XSLT. Nous allons donc modifier le fichier XSLT, en ajoutant des balises, comme 

ceci : 

 

XSLT 179 

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 

 


 

 

Cette fois, si vous ouvrez le document « test.xml », vous devriez voir le texte « On doit 

mettre quelque chose ici!!! » s’afficher dans votre navigateur. Faites l’expérience. 

Dans les exemples que nous allons proposer, nous omettons les éléments « html » et 

« body » par souci de simplicité. La présence de ces éléments n’est pas nécessaire et 

n’est utile que pour afficher le résultat dans un navigateur. À vous de les ajouter si vous 

désirez afficher le résultat. 

Pour résumer, chaque fois que le processeur XSLT rencontre un élément « facture 

», il applique le modèle qui se trouve dans l’élément « ». Notez que si l’élément « facture » contient lui-même des éléments, 

ils ne sont pas automatiquement visités par le processeur XSLT. Ce dernier 

considère que dès qu’un modèle est appliqué à un élément, il peut alors parcourir le 

reste du document sans se soucier du contenu de cet élément qui est maintenant « couvert 

». 

3.2.9 « Éléments xsl:value-of » 

Jusqu’à présent, le résultat n’est pas très fascinant parce que les éléments 

« xsl:template » ont été utilisés comme des outils pour faire du « Rechercher/Remplacer 

». Le contenu de l’élément « facture » n’est pas traité, on le remplace 

bêtement par autre chose. 

Nous pouvons traiter le contenu d’un élément à l’aide d’un élément « xsl:value-of » 

avec la syntaxe . La valeur de l’élément « select » est un 

chemin (appelé expression XPath) : les chemins les plus simples sont constitués du 

nom d’un sous-élément. Par exemple, si le processeur traite un élément « facture » 

qui contient un élément « montant », alors l’élément nous donne le contenu de l’élément « montant ». C’est ainsi que nous pouvons 

trouver le nom de la personne devant recevoir une facture, en utilisant . 

Voyons maintenant un exemple plus complexe de fichier XSLT : 

 

 

 

 

 

Facture de 

CC BY-NC-SA


 

 

Ceci est une facture pour 

de $ pour: 

. 

 

 

 

 

Si vous modifiez le fichier « xslt.xml » et que vous ouvrez le fichier « test.xml » dans un 

navigateur supportant le XSLT (comme Firefox), vous devriez voir s’afficher à l’écran 

la ligne « Ceci est une facture pour Jean Rochond de 10.10$ pour: Achat d’ordinateur. 

». Il faut avouer que c’est déjà beaucoup plus intéressant comme application! 

Ce qui se passe, c’est que le nouveau document XSLT transforme notre document XML 

en un document HTML : 

 

 

 

Facture de Jean Rochond 

 

Ceci est une facture pour Jean Rochond 

de 10.10$ pour: Achat d’ordinateur. 

 

Pour résumer, nous pouvons aller chercher le contenu textuel d’une expression 

XPath avec une instruction comme « » où « ... » est 

une expression XPath comme le nom de l’élément. 

3.2.10 Arithmétique en XPath 

Nous pouvons aussi nous servir des expressions XPath pour faire du calcul simple. Par 

exemple, les trois expressions suivantes donneront 2, 2 et 2.5 respectivement : 

 

 

 

Il arrive qu’on doive calculer une somme de nombres. Par exemple, supposons qu’un 

facture comporte une liste de montants. 

 

XSLT 181 

type="application/xml"> 

 

10.10 

20.10 

40.10 

 

La fonction XPath « sum » nous permet de calculer la somme des montants sans effort 


 

 

 

 

 

 

 

 

 

 

Comme en Java, on a aussi les fonctions « floor », « ceiling », « mod » et « round ». 

On peut aussi utiliser les paranthèses dans toutes expressions XPath : « (5 + 2) div 2 ». 

3.2.11 Manipulations des chaînes de caractères en XPath 

Outre les fonctions arithmétiques, on peut aussi manipuler les chaînes de caractères en 

XPath. La fonction la plus simple est « string-length ». Elle calcule la longueur d’une 

chaîne. Une autre fonction simple est « normalize-space » qui élimine tous les espaces 

au début et à la fin d’une chaîne en plus de remplacer les espaces répétés par un espace 

simple. La fonction « translate » permet de remplacer des caractères. Par exemple, pour 

remplacer les é par des e et les à par des a, on pourrait utiliser l’instruction suivante 

« translate("à la vérité","éà","ea") » qui renvoie « a la verite ». 

On peut extraire des sous-chaînes de caractères de diverses manières : la fonction « substring 

» permet d’extraire une sous-chaîne lorsqu’on en connaît sa position et sa longueur, 

la fonction « substring-after » permet d’aller chercher un suffixe, la fonction 

« substring-before » permet d’aller chercher un préfixe. Par exemple, « substring("la 

vie est belle",3,7) » renvoie « vie est », « substring-after("la vie est belle","est") » renvoie 

« belle » alors que « substring-before("la vie est belle","est") » renvoie « la vie » 

On peut aussi additionner deux chaînes de caractères pour en faire une seule avec la 

fonction « concat ». L’expression « concat("a","b") » a comme valeur "ab". 

CC BY-NC-SA


On peut tester une chaîne pour la présence d’une sous-chaîne avec la fonction XPath 

« contains ». L’expression « contains("abc","bc") » est vraie parce que "bc" est une 

sous-chaîne de "abc", alors que l’expression « contains("abc","bz") » est fausse. 

3.2.12 Chemins XPath plus sophistiqués 

Supposons maintenant que nous devions traiter un document XML un peu plus complexe, 

comme celui qui suit : 

 

 

 

10.10 

 

M 

Rochond 

Jean 

 


 

Observez que l’élément « personne » contient maintenant trois sous-éléments : sexe, 

nom et prenom. Quand on demande au XSLT d’inclure le contenu d’un élément, à 

l’aide d’une instruction « xsl:value-of », il retire d’abord toutes les balises. Il garde 

les espaces entre les éléments, le texte, et les retours de chariot; seules les balises sont 

retirées. En somme, le résultat de l’instruction « xsl:value-of » appliqué à un élément 

est son contenu textuel. Précisons que dans le cas où on sélectionne non pas un élément, 

mais plusieurs, l’instruction value-of ne s’applique qu’au premier élément rencontré. 

Ainsi, si nous utilisions le fichier XSLT précédent destiné à des éléments « personne » 

ne contenant que du texte, nous obtiendrions à l’écran, dans Firefox, le texte « Ceci est 

une facture pour M Rochond Jean de 10.10$ pour: Achat d’ordinateur. ». Pourquoi ce 

résultat Parce qu’à l’endroit où se trouve s’insère 

le contenu de l’élément, sans le balisage, ce qui fait que seul le contenu des souséléments, 

dans l’ordre, est affiché. 

De façon concrète, le fichier XML est transformé en contenu HTML : 

 

 

 

Facture de 

M 

Rochond 

Jean 

 

CC BY-NC-SA

XSLT 183 

 

Ceci est une facture pour 

M 

Rochond 

Jean 

de 10.10$ pour: Achat d’ordinateur. 

 

Par ailleurs, nous pouvons modifier le fichier XSLT pour aller chercher le contenu 

respectif des sous-éléments « prenom » et « nom ». Pour ce faire, il suffit de remplacer 

« select="personne" » par « select="personne/prenom" » et « select="personne/nom" », 

car la valeur de l’attribut « select » se comporte un peu comme dans les adresses web : 

le symbole « / » entre deux noms d’élément signifie « sous-élément ». Nous pourrons 

alors utiliser le fichier XSLT suivant : 

 

 

 

 

 

Facture de 

 

 


de $ 

pour: . 

 

 

 

 

Si nous testons ce nouveau fichier XSLT dans Firefox, nous constaterons que le résultat 

est presque correct : cette fois-ci, le fichier « test.xml » s’affiche comme « Ceci est une 

facture pour JeanRochond de 10.10$ pour: Achat d’ordinateur. ». 

Notez qu’il manque un espace entre Jean et Rochond. Cela se produit parce que dans 

un document XSLT, on ignore les espaces entre les éléments (dans le cas où il n’y a 

que des espaces entre les deux éléments) : pour obtenir un espace, il faut en marquer la 

présence en insérant un élément « xsl:text » comme ceci : 

 

 

 

 

CC BY-NC-SA


 

Facture de 

 

 


 

 

de $ pour: 

. 

 

 

 

 

En effet, alors que les espaces entre les éléments sont ignorés, l’espace dans un élément 

« xsl:text » sera pris en compte. Attention à la confusion : les espaces entre les éléments 

sont ignorés dans le fichier XSLT, mais pas dans le fichier XML qui est traité! 

Nous constatons que les chemins XPath peuvent contenir non seulement le nom d’un 

élément, mais aussi le nom d’un sous-élément, comme « personne/prenom ». Cela peut 

nous permettre de construire des modèles complexes qui peuvent aller extraire des 

valeurs contenues dans des sous-éléments. 

3.2.13 Modularité avec les éléments « xsl:apply-templates » 

Notre fichier « xslt.xml » se complexifie et devient plus difficile à comprendre. Tout est 

dans un seul modèle, le modèle facture. Pour simuler un problème probable, imaginons 

que notre XML est plus complexe et prend la forme : 

 

 

 

10.10 

 

 

M 

Rochond 

Jean 

 

 

 

 

F 

Ladouce 

Jeanne 

CC BY-NC-SA

XSLT 185 

 

 


 

Dans ce nouveau document XML, se trouvent deux éléments « personne ». Il serait 

bête, dans le document XSLT, de répéter le travail chaque fois qu’on veut afficher un 

élément « personne ». Regardons ce que cela pourrait donner en pratique : 

 

 

 

 

 

Facture de 

 

 


 

 

 

de $ pour: 

. 

Votre commerçant: 

 

 

 

 

 

 

 

Observez comment on répète le texte suivant à deux reprises : 

 

 

 

Voici une autre solution, plus élégante, qui donne le même résultat : 

 

 

 

CC BY-NC-SA


 

 

 

Facture de 

 

 


 

de $ pour: 

. 

Votre commerçant: 

 

 

 

 

 

 

 

 

 

 

Quelques éléments « xsl:value-of » ont été remplacés par des éléments « xsl:applytemplates 

». Un élément « xsl:apply-templates » prend le contenu et, au lieu d’insérer 

le contenu textuel comme le fait « xsl:value-of » à l’endroit prévu, il insère plutôt le 

résultat obtenu par l’application de modèles (éléments « xsl:template »). Ainsi, dans 

l’exemple que nous venons de voir, chaque fois que le processeur XSLT rencontre 

l’instruction « », il prend l’élément « recipiendaire 

» et essaie d’appliquer ses modèles. Comme il n’a pas de modèle pour les 

éléments « recipiendaire », il explore le contenu de l’élément et y trouve immédiatement 

un élément « personne ». Puisqu’il dispose d’un modèle pour ce type d’élément, il 

va l’appliquer. Par ailleurs, comme les éléments « recipiendaire » et « commercant » ne 

contiennent qu’un élément « personne », c’est donc le modèle défini pour les éléments 

« personne » qui s’appliquera dans les deux cas. 

Normalement, les éléments « xsl:apply-templates » sont utilisés au sein des éléments 

« xsl:template ». On peut aussi les utiliser au sein d’autres éléments que nous discuterons 

prochainement, « xsl:param » et « xsl:variable ». 

Notre fichier « xslt.xml » est maintenant plus modulaire, parce qu’il contient deux 

modèles (éléments « xsl:template »). 

En résumé, il est souvent préférable d’utiliser un élément « xsl:apply-templates » 

qu’un élément « xsl:value-of » quand la complexité du modèle augmente; ceci 

permet d’assurer la modularité et de garder la simplicité du document XSLT. 

CC BY-NC-SA

XSLT 187 

Par défaut, l’instruction apply-templates traite les documents dans l’ordre où ils se présentent 

dans le document original. On peut forcer le XSLT à trier les éléments avant 

de le traiter avec l’instruction xsl:sort. Dans notre exemple, on peut remplacer l’élément 

par cet élément si on veut que les 

individus soient triés par leur nom de famille. 

 

 

 

Si on souhaite un tri sur la valeur numérique d’une expression, on remplacera datatype="text" 

par data-type="number". 

On peut aussi importer un autre fichier XSLT avec l’instruction xsl:import. Celle-ci doit 

apparaître au tout début du fichier XSLT comme premier sous-élément de l’élément 

xsl:stylesheet comme dans cet exemple : 

 

 

 

 

 

 

Facture de 

 

 

 

En cas de conflit entre les règles de fichier XSLT principal et celles du fichier importé, 

les règles du fichier XSLT principal l’emporte. 

3.2.14 Chemins XPath pour la sélection des attributs 

Maintenant que nous avons un document XSLT modulaire, il est plus facile de l’enrichir. 

Supposons que le document XML contienne des attributs... Le numéro d’assurance 

sociale des individus peut être indiqué par des attributs « nas », en utilisant le 

symbole « @ » dans l’expression XPath, comme dans l’exemple qui suit : 

 

 

 

10.10 

 

 

M 

CC BY-NC-SA


Rochond 

Jean 

 

 

 

 

F 

Ladouce 

Jeanne 

 

 


 

En outre, si nous voulons afficher le numéro d’assurance sociale de l’individu entre 

parenthèses, nous pourrons utiliser le fichier « xslt.xml » suivant : 

 

 

 

 

 

Facture de 

 

 


 

de $ pour: 

. 


 

 

 

 

 

 

 

( ) 

 

 

CC BY-NC-SA

XSLT 189 

Notez que le chemin XPath « » ne donne pas le contenu 

de l’élément « nas », mais plutôt la valeur de l’attribut ayant pour nom « nas ». 

3.2.15 Expression XPath « . » 

Supposons que, dans un modèle, nous voulions obtenir non pas la valeur d’un attribut 

ou d’un sous-élément, mais la valeur de l’élément lui-même. On obtient ce résultat 

avec l’expression XPath « . » (un point). Par exemple, nous pourrions définir le modèle 

suivant : 

 

 

 

Dans l’expression « select="." », le point représente l’élément courant, c’est-à-dire 

l’élément « prenom ». Donc, l’élément « » donne le contenu 

de l’élément « courant ». Nous pourrions remplacer le fichier XSLT précédent par celui 

qui suit et obtenir les mêmes résultats : 

 

 

 

 

 

Facture de 

 

 


 

de $ pour: 

. 


 

 

 

 

 

 

 

( ) 

 

 

CC BY-NC-SA


 

 

 

Nous pourrions objecter que les instructions « » et « » 

sont étranges puisqu’il n’y a pas de modèle « recipiendaire » ou « commercant ». 

Cependant, la règle par défaut qui s’applique aux éléments est d’appliquer les modèles 

à leurs sous-éléments et ainsi de suite. 

3.2.16 Spécifier les valeurs d’attributs 

Nous savons maintenant comment aller chercher la valeur d’un attribut en utilisant une 

expression XPath contenant le symbole « @ ». Cependant, qu’en est-il de la spécification 

des valeurs d’attributs Supposons le document suivant : 

 

10.10 

 

Nous voulons le simplifier pour n’avoir que : 

 

Nous pouvons obtenir ce résultat en utilisant les accolades, pour indiquer une valeur 

XPath comme valeur d’attribut, de la façon suivante : 

 

 

 

 

 

 

Expression XPath «.» 

3.2.17 Expression XPath « .. » 

L’expression « select=".." » (deux points successifs) peut être utilisée pour représenter 

l’élément dans lequel se trouve l’élément courant. Ainsi, dans le modèle suivant 

CC BY-NC-SA

XSLT 191 

 

 

 

l’instruction « » donne la valeur (texte contenu dans 

l’élément sans les balises) de l’élément « personne » dans lequel est contenu l’élément 

« prenom ». Nous pouvons aller chercher le parent du parent avec l’instruction 

. 

Lorsque l’élément courant est l’élément-racine, l’expression « .. » (deux points successifs) 

ne devrait pas être utilisée. 

3.2.18 Expression XPath « // » 

Parfois, il est avantageux de sélectionner par nom tous les éléments qui sont dans l’élément 

courant ou dans un sous-élément; nous pouvons obtenir ce résultat avec l’expression 

XPath « // » (deux barres obliques). L’expression XPath « //prenom » sélectionne 

tous les éléments prenom incluant ceux qui seraient contenus dans un élément nom, par 

exemple. L’instruction donnera donc le contenu 

textuel du premier élément personne recontré dans le document. 

3.2.19 Expression XPath « * » 

Parfois, il est avantageux de sélectionner tous les éléments qui sont dans l’élément 

courant; nous pouvons obtenir ce résultat avec l’expression XPath « * » (astérisque). 

Par exemple, le modèle qui suit s’applique à tous les éléments : 

 

Ceci est un élément. 

 

Une expression avec « @* » sélectionne tous les attributs contenus dans un élément. 

Dans certains cas, plus d’un modèle s’applique à un élément donné : en cas de doute, le 

processeur applique le modèle le plus « spécifique »; le modèle pour « * » ne s’applique 

que s’il n’existe aucun autre modèle. 

De la même façon, nous pouvons indiquer au processeur XSLT d’appliquer les règles 

à tous les éléments, en utilisant la syntaxe . 

3.2.20 Expression XPath avec « | » 

Parfois, nous voulons sélectionner plusieurs noms d’éléments; nous pouvons obtenir 

ce résultat avec le symbole « | » (barre verticale) qui signifie « union ». Par exemple, le 

CC BY-NC-SA


modèle qui suit s’applique à tous les éléments « facture » et « montant », et seulement 

à ces éléments : 

 

Ceci est un élément facture ou montant. 

 

3.2.21 Expression XPath pour le nom d’un élément 

Supposons que nous voulions afficher uniquement les noms des éléments (sans leur 

contenu). Nous pouvons obtenir ce résultat avec la fonction XPath « name » qui donne 

le nom de l’élément. La fonction name inclut le préfixe de l’espace de noms. Si on 

souhaite le nom de l’élément sans le préfixe, on peut utiliser la fonction « local-name ». 

La fonction « namespace-uri » donne l’URI de l’espace de noms de l’élément. 

Ainsi, le document XSLT suivant permet d’afficher tous les noms des éléments XML, 

sans le contenu textuel de ces éléments. 

 

 

 

 

 

 

 

Nous pourrions aussi vouloir afficher non seulement le nom de l’élément courant, mais 

aussi le nom de l’élément-parent, ce qu’on peut faire avec le document XSLT suivant : 

 

 

 

/ 

 

 

 

3.2.22 Notion de nœuds XSLT 

Un processeur XSLT traite un fichier XML en partant du début et en appliquant ses 

règles au fur et à mesure qu’il rencontre des éléments. Rappelons que si le processeur 

CC BY-NC-SA

XSLT 193 

XSLT rencontre un élément pour lequel il n’a aucune règle (modèle), il visite tous les 

sous-éléments et applique le modèle par défaut, soit reproduire le texte quand il en 

rencontre, en omettant les balises. 

Une autre façon de décrire ce comportement est de dire que le XSLT utilise un modèle 

de fichiers XML « en arbre de nœuds ». Imaginons un arbre où, à la racine, se trouve 

un nœud spécial représentant le document dans son ensemble. Avec XPath, nous pouvons 

pointer directement sur le nœud-racine (le document lui-même) en utilisant la 

barre oblique « / » que nous plaçons au début de l’expression XPath, comme dans 

« ». Dans ce cas, « » donne 

la valeur de l’élément-racine, si celui-ci se nomme « jean ». 

Le nœud-racine contient lui-même l’élément-racine. Chaque élément et chaque élément 

de texte sont aussi des nœuds dans ce modèle d’arbre XSLT. Alors que les nœuds 

de texte ne peuvent pas contenir d’autres nœuds, les nœuds d’élément peuvent contenir 

plusieurs autres nœuds dont d’autres nœuds d’élément et de texte. 

Ainsi, par défaut, le processeur XSLT qui atteint un élément visite tous les éléments et 

les nœuds de texte qu’il contient. Un nœud de texte rencontré est simplement recopié, 

par défaut, alors que pour les éléments, on visite également leur contenu. C’est ce qui 

explique que, par défaut, s’il n’y a aucune règle dans le document XSLT, un document 

XML est recopié sans les balises. 

D’autres nœuds existent comme les nœuds de commentaire, les nœuds d’instructions 

de traitement et les nœuds d’espaces de noms, mais ils sont moins importants que 

le nœud du document (nœud-racine), les nœuds d’attribut, les nœuds de texte ou les 

nœuds d’élément. Dans le modèle d’arbre, les nœuds d’espaces de noms et les nœuds 

d’attribut sont attachés à l’élément, mais ne sont pas un enfant (« child »). 

Nous avons déjà vu que « * » et « @* » permettaient de sélectionner les sous-éléments 

et attributs d’un élément. On peut sélectionner les nœuds de texte avec la fonction 

XPath « text() ». Notons aussi que l’élément « » signifie que 

les modèles s’appliquent à tous les nœuds contenus dans le nœud courant. Les règles 

par défaut qui s’appliquent en XSLT sont : 

 

 

 

 

 

 

 

En résumé, un processeur XSLT représente un document XML comme un arbre et 

tente de le visiter de la racine vers les feuilles. Lorsqu’il rencontre un modèle pour un 

CC BY-NC-SA


nœud, il l’applique et ne poursuit pas automatiquement la visite des nœuds qui y sont 

contenus, à moins de rencontrer un élément « xsl:apply-templates ». 

3.2.23 Expressions XPath pour compter et additionner les éléments 

Avec XSLT et XPath, on peut faire un certain nombre d’opérations, comme compter 

les éléments. La fonction XPath « count » compte le nombre de nœuds (éléments) 

sélectionnés. Soit le document XML suivant : 

 

10.10 

20.10 

 

Supposons qu’on veuille calculer automatiquement le nombre d’éléments « montant » 

pour obtenir quelque chose comme ceci : 

 

Il suffit simplement d’utiliser la fonction « count », comme dans l’exemple de document 

XSLT qui suit : 

 

 

 

 

 

 

Supposons maintenant qu’on veuille numéroter les montants pour bien indiquer quel 

montant apparaît en premier, quel montant apparaît en deuxième, et ainsi de suite. 

Pour ce faire, il n’y a pas d’expression XPath appropriée, mais nous pouvons obtenir 

le résultat désiré à l’aide de l’élément XSLT « xsl:number » et son attribut « count ». 

En effet, le document XSLT qui suit : 

 

 

 

 

 

 

CC BY-NC-SA

XSLT 195 

Montant numero 

est . 

 

 

permet d’obtenir le résultat suivant : 

Montant numero 1 est 10.10. 

Montant numero 2 est 20.10. 

L’élément « xsl:number » avec l’attribut « count » permet de numéroter des éléments 

sur la base de leur nom, que l’on utilise comme valeur de l’attribut « count ». 

On peut aussi additionner des nombres avec la fonction XPath « sum ». L’exemple 

suivant fera la somme des valeurs numériques contenues dans les éléments « montant » 

(10.10 et 20.10). 

 

 

 

 

 

 

3.2.24 Utilisation de l’attribut « mode » 

Il arrive que nous voulions définir plus d’un modèle pour un élément donné. Nous pouvons 

ajouter des modèles en utilisant l’attribut « mode » qui s’applique aux éléments 

« xsl:apply-templates » et « xsl:template ». La règle est très simple : si votre élément 

« xsl:apply-templates » a une valeur d’attribut pour « mode », alors seuls les éléments 

« xsl:template » ayant la même valeur d’attribut pour « mode » s’appliquent. On utilise 

souvent l’attribut « mode » pour faire des tables des matières. 

Prenons, par exemple, la liste de cours suivants : 

 

 

INF 102 Introduction avancée 

Un cours d’introduction à l’informatique pour futurs 

ingénieurs. 

INF 101 Introduction 

Un cours d’introduction à l’informatique pour les 

étudiants en éducation. 

INF 103 Java 

CC BY-NC-SA


Un cours d’introduction au Java 

 

Nous pourrions vouloir que s’affiche d’abord seulement la liste des noms de cours et 

que cette dernière soit suivie d’une liste détaillée comprenant le nom et la description 

du cours : 

La liste des cours en bref: 

– INF 102 Introduction avancée 

– INF 101 Introduction 

– INF 103 Java 

La liste détaillée des cours: 

– INF 102 Introduction avancée: Un cours d’introduction à l’informatique pour futurs 

ingénieurs. 

– INF 101 Introduction: Un cours d’introduction à l’informatique pour les étudiants 

en éducation. 

– INF 103 Java: Un cours d’introduction au Java 

Nous pouvons obtenir ce résultat avec le document XSLT suivant qui utilise l’attribut 

« mode » : 

 

 

 

 


 

 

 


 

 

 

 

 

 

 

 

 

: 

 

 

CC BY-NC-SA

XSLT 197 

 

3.2.25 Fonction « generate-id » 

La fonction XSLT « generate-id » génère un « nom » unique pour chaque élément d’un 

document XML. Ce nom sera toujours le même pour un même élément, même si nous 

le rencontrons à plusieurs reprises. Si nous reprenons la liste des cours de l’exemple 

précédent sur l’utilisation de l’attribut « mode », nous pourrions générer un identifiant 

unique pour chaque cours et l’afficher comme dans l’exemple de document XSLT qui 

suit : 

 

 

 

 

La liste des cours en bref : 

 

 

 

La liste détaillée des cours : 

 

 

 

 

 

 

 

(identifiant: ) 

 

 

: 

 

(identifiant: ) 

 

 

Nous pourrions alors obtenir un résultat comme celui-ci : 


– INF 102 Introduction avancée (identifiant: id2243749) 

– INF 101 Introduction (identifiant: id2243760) 

– INF 103 Java (identifiant: id2243686) 

CC BY-NC-SA



– INF 102 Introduction avancée: Un cours d’introduction à l’informatique pour futurs 

ingénieurs. (identifiant: id2243749) 

– INF 101 Introduction: Un cours d’introduction à l’informatique pour les étudiants 

en éducation. (identifiant: id2243760) 

– INF 103 Java: Un cours d’introduction au Java (identifiant: id2243686) 

Les valeurs exactes que prennent les identifiants sont sans importance, mais il importe 

que ce soit toujours la même valeur pour un même élément. Par exemple, le cours sur 

Java obtient toujours l’identifiant « id2243686 » dans notre exemple. 

3.2.26 Utilisation des tests 

Nous pouvons tester des conditions à l’aide d’expressions XPath contenant les symboles 

« < », « = », « != », « or », « and », « > », « >= », «

XSLT 199 

On peut aussi combiner plusieurs tests avec les opérateurs logiques and, or et not 

comme le montre le prochain exemple. 

 

 

 

Il y a une balise "montant" ou une 

balise "facture" 

 

 

Ce n’est ni montant, ni facture, ni argent. 

 

 

Je ne connais pas cet élément. 

 

 

 

On peut aussi tester la langue d’un élément avec la fonction XPath « lang ». L’expression 

« count(//p[lang(’en’)]) » compte le nombre d’élément « p » ayant été déclaré 

comme contenant du texte en langue anglaise. 

Observez qu’un élément « xsl:choose » contient plusieurs éléments « xsl:when » 

qui sont testés tour à tour, jusqu’à ce qu’une condition soit vraie; l’élément 

« xsl:otherwise » est présent pour l’éventualité où tous les tests échouent. Tous les 

tests sont réalisés en séquence et dès qu’une condition est vraie, les tests s’arrêtent et 

le contenu de l’élément « xsl:when » est évalué. 

En XSLT, il ne faut pas abuser des tests; il est préférable d’utiliser des éléments 

« xsl:template » qui sont plus modulaires. 

3.2.27 Tester le contenu des chaînes de caractères 

Nous avons vu comment comparer le nom ou le contenu d’un élément avec une chaîne 

de caractères donnée, mais il arrive qu’on veuille faire des comparaisons plus fine. 

Heureusement, il existe des fonctions XPath permettant d’analyser le contenu des 

chaînes. Par exemple, « starts-with("a",@toto) » renvoie la valeur vraie si et seulement 

si la valeur de l’attribut « toto » débute avec la lettre « a ». L’expression « endswith("a",@toto) 

» est vraie si et seulement si la valeur de l’attribut « toto » se termine 

avec la lettre « a ». De la même façon, « contains("abc",@toto) » renvoie la valeur vraie 

si et seulement si la valeur de l’attribut « toto » contient la chaîne « abc » (comme dans 

« j’ai un abc »). 

CC BY-NC-SA


3.2.28 Accès aux éléments d’un ensemble d’éléments 

Avec XSLT, nous pouvons traiter du XML un peu comme nous traitons un tableau en 

Java ou en C/C++. Par exemple, supposons que nous ayons une liste de clients avec 

leur numéro de téléphone, comme ceci : 

 

 

Jacques 

Sylvain 

Claude 

Yvon 

 

Notez que l’expression XPath « /listedeclients/client » est en fait une séquence (ensemble 

ordonné) d’éléments. Ainsi, « /listedeclients/client[2] » représente le deuxième 

(et non le troisième!) élément « client », celui dont le nom est « Sylvain ». 

Maintenant, si nous voulons obtenir le numéro de téléphone du deuxième client de 

la liste, il faut d’abord ajouter le symbole « / » (barre oblique) pour indiquer qu’on 

cherche un sous-nœud de l’élément en question, suivi de « @telephone » pour désigner 

l’attribut « telephone ». Le document XSLT suivant nous donnerait le numéro de 

téléphone désiré : 

 

 

 

 

 

 

Ou, plus simplement : 

 

 

 

 

 

 

Notez que l’expression « /listedeclients/client[0] » n’est pas valable, car la numérotation 

des éléments d’une séquence débute à 1 en XSLT, contrairement à Java et à C/C++. 

CC BY-NC-SA

XSLT 201 

Notez aussi qu’on aurait pu obtenir le même résultat avec l’expression XPath « (/listedeclients/client/@telephone)[2] 

», car « /listedeclients/client/@telephone » est aussi 

une séquence (mais une séquence d’attributs). Nous devons toutefois ajouter une parenthèse 

pour marquer la priorité des opérations. En effet, la syntaxe « a/b[2] » signifie : 

deuxième nœud de type « b » dans les nœuds de type « b ». Comme il ne peut y avoir 

qu’un seul attribut d’un type donné dans un élément, la syntaxe « a/@b[2] » donnera 

toujours un ensemble vide. D’un autre côté, la syntaxe « (a/b)[2] » signifie : deuxième 

nœud de type « b » dans la séquence des nœuds de type « b » contenus dans les nœuds 

de type « a ». De la même manière, « //b[2] » donne la liste de tous les éléments b « b » 

dans le document apparaissant deuxième dans la liste des éléments contenus dans un 

autre élément, alors que « (//b)[2] » est le deuxième élément « b » rencontré dans tout 

le document. 

Vous croyez avoir bien compris Quelle est la différence entre « (b)[2] » et « b[2] » 

Quelle est la différence entre « (b[2])/a » et « b[2]/a » 

3.2.29 Utiliser XSLT comme base de données et éléments « foreach 

» 

L’exemple de la liste des clients avec leur numéro de téléphone nous permet de 

faire plus. Nous pouvons y utiliser XSLT comme « moteur (primitif) de base 

de données », en cherchant les éléments selon leur contenu. L’expression XPath 

« /listedeclients/client[nom=’Sylvain’] » nous donnera les éléments pour lesquels 

le contenu du sous-élément « nom » est « Sylvain ». L’expression plus complète 

« /listedeclients/client[nom=’Sylvain’]/@telephone » pointera directement sur l’attribut 

« telephone » dont la valeur est « 545-5455 ». D’un autre côté, l’expression 

XPath « /listedeclients/client[@telephone=’533-3445’]/nom », nous donnera l’élément 

« nom » contenant le nom du client ayant le numéro de téléphone indiqué. 

L’absence du symbole « = » dans le crochets indique qu’il s’agit d’un test d’existence. 

Ainsi, « /listedeclients/client[nom] » donne les éléments « client » qui ont un sousélément 

« nom ». De la même façon, « /listedeclients/client[@telephone] » donne les 

éléments « client » qui ont un attribut « telephone ». 

Supposons maintenant que nous soyons devant un fichier XML comme celui-ci : 

 

 

 

Jacques 

Sylvain 

Claude 

Yvon 

 

 

Arthur 

CC BY-NC-SA


Sylvain 

Claudette 

Yvon 

 

 

Il est maintenant plus fastidieux de trouver le numéro de téléphone d’un certain client, 

car il faut visiter tous les vendeurs. De plus, chaque vendeur peut avoir un numéro de 

téléphone (possiblement différent) pour chaque client. Comme nous allons le voir, le 

XSLT permet de gérer assez facilement ces situations. 

Tout d’abord, l’expression « //client » donne une séquence de tous les éléments 

« client » dans le nœud courant. Avec l’expression XPath « //client[nom=’Sylvain’] », 

nous pouvons obtenir la séquence de tous les éléments « client » ayant pour nom « Sylvain 

». Dans ce cas précis, il y a plus d’un élément dans la réponse. Pour visiter l’ensemble 

des éléments dans la séquence, il suffit d’utiliser l’élément « xsl:for-each » 

comme ceci : 

 

 

 

Numéros de téléphone pour Sylvain: 

 

 

 

 

 

 

 

 

Le résultat de l’application de ce fichier XSLT au fichier XML contenant les numéros 

de téléphone sera : 

Numéros de téléphone pour Sylvain: 

 

545-5455 

545-5456 

 

 

CC BY-NC-SA

XSLT 203 

Dans une telle boucle, il peut être utile de savoir quel est le numéro du nœud courant. 

On obtient ce numéro avec la fonction XSLT « position() » qui a la valeur 1 quand il 

s’agit du premier nœud et la valeur « last() » quand il s’agit du dernier nœud. On peut 

aussi utiliser une instruction xsl:sort au sein d’un élément for-each. 

Supposons maintenant que nous voulions compter le nombre de fois qu’un client est 

dans la base de données. Un modèle XSLT comme celui qui suit semble une bonne 

piste : 

 

 

 

Malheureusement, entre les crochets (partie conditionnelle de l’expression XPath), le 

symbole « . » ne représente plus l’élément « client » XSLT courant, mais bien chacun 

des éléments « client » du document tour à tour : la condition « nom=./nom » est ici 

toujours satisfaite. Heureusement, il existe une fonction XSLT, appelée « current() », 

qui représente toujours l’élément XSLT courant. Donc, si nous voulons parcourir tout 

le document et trouver combien de fois chaque client est dans la liste, nous pourrions 

utiliser le document XSLT suivant : 

 

 

 

 

 

 

 

 

Nom du vendeur: 

 

 

 

: 

 

 

 

Le résultat de la transformation sera alors : 

CC BY-NC-SA


 

 

Nom du vendeur: Jean 

 

Jacques: 

1 

Sylvain: 

2 

Claude: 

1 

Yvon: 

2 

 

 

 

Nom du vendeur: Raymond 

 

Arthur: 

1 

Sylvain: 

2 

Claudette: 

1 

Yvon: 

2 

 

 

 

Nous verrons dans la section suivante comment faire pour ne présenter chaque client 

qu’une seule fois. 

3.2.30 Obtenir l’aggrégation avec la fonction « generate-id » 

Supposons qu’on veuille calculer le total des éléments « quantite », mais en faisant 

l’aggrégation pour chaque valeur de l’attribut « type » dans l’exemple suivant. 

 

 

 

 

53 

12 

 

CC BY-NC-SA

XSLT 205 

 

14 

12 

 

 

On pourrait tenter de résoudre ce problème avec une expression XPath de la forme 

« sum(//quantite[@type=current()/@type]) ». Malheureusement, on risque alors de calculer 

plusieurs fois la même somme. Par exemple, tentez d’appliquer la transformation 

suivante : 

 

 

 

 

 

 

 

 

 

 

 

 

- 

 

 

 

Vous obtiendrez alors le résultat suivant : 

 

bain 

- 67 

chambre 

- 24 

bain 

- 67 

chambre 

- 24 

 

Pour calculer la somme qu’une seule fois pour chaque valeur de l’attribut type, on 

pourrait ne faire le calcul que la première fois qu’on rencontre une valeur d’attribut 

CC BY-NC-SA


donnée. L’expression XPath « //quantite[@type=x] » représente l’ensemble des éléments 

quantite ayant un attribut de valeur x. L’expression « //quantite[@type=x][1] » 

nous donne le premier élément de ce type rencontré. On pourrait penser que l’expression 

XPath « //quantite[@type=x][1]=current() » permet de déterminer si le nœud 

courant est le premier. Malheureusement, cette expression XPath vérifie plutôt si 

les deux éléments ont le même contenu. Comme nous avons deux éléments quantite 

ayant le même contenu dans notre exemple, cette solution ne suffit pas. La 

fonction generate-id quant à elle associe un identifiant unique à chaque nœud d’un 

document XML et permet donc de distinguer les éléments entre eux même lorsqu’ils 

ont le même contenu. L’expression « //quantite[@type=current()/@type]) » 

donne la séquence de tous les éléments quantite ayant un attribut type de même 

valeur que l’élément courant, alors que « (//quantite[@type=current()/@type])[1] » 

sélectionne le premier de cette liste. On peut vérifier si l’élément « quantite » 

est le premier du document ayant un certain type avec la fonction « generateid 

» et l’expression « generate-id((//quantite[@type=current()/@type])[1]) = generateid(.) 

». On peut aussi vérifier que c’est le dernier avec l’expression « generateid((//quantite[@type=current()/@type])[last()]) 

= generate-id(.) ». En utilisant cette astuce, 

on peut obtenir l’aggrégation souhaitée avec le programme XSLT suivant où l’on 

fait la somme seulement pour le premier élément rencontré ayant un certain type : 

 

 

 

 

 

 

 

 

 

 

 

 

 

- 

 

 

 

 

On peut appliquer cette technique à notre exemple de la section précédente avec les 

vendeurs et les clients. La transformation suivante permet de ne calculer la fréquence 

de chaque client qu’une seule fois. 

CC BY-NC-SA

XSLT 207 

 

 

 

 

 

 

 

 

 

 

 

 

: 

 

 

 

 

Le résultat de cette transformation donne une liste désordonnée de clients : 

 

Jacques: 

1 

Sylvain: 

2 

Claude: 

1 

Yvon: 

2 

Arthur: 

1 

Claudette: 

1 

 

On peut trier le nom des clients en utilisant un élément xsl:sort : 

 

 

CC BY-NC-SA


 

 

 

 

 

: 

 

 

 

 

 

 

3.2.31 Un peu plus de performance avec la function XSLT « key » 

Le problème avec l’utilisation d’expressions XPath telles que 

//client[nom=current()/nom] est qu’elles peuvent s’avérer coûteuses en temps de 

calcul si on les utilisent à répétition. Afin d’accélérer les choses et simplifier un 

peu nos programmes, on peut créer un tableau associatif avec l’élément xsl:key et 

sa fonction correspondante key. Un tableau associatif est simplement une structure 

de donnée qui associe à chaque clef ou au plusieurs valeurs. Puisque ce tableau est 

construit une seule fois lorsque le processeur rencontre l’élément xsl:key, le processeur 

XSLT n’a pas à visiter les nœuds du document plusieurs fois. L’élément xsl:key 

comprend trois attributs incluant le nom du tableau associative (name), les clefs à 

inclure (use) et les nœuds à traiter (match). L’instruction va créer un tableau associatif s’appelant montableau et 

qui associe à chaque valeur client/nom l’élément nom correspondant. La fonction key 

quant à elle prend deux paramètres incluant le nom du tableau et la valeur de la clef. À 

titre d’exemple, la transformation suivante permet de calculer la fréquence de chaque 

client comme à la question précédente, mais en utilisant un tableau associatif : 

 

 

 

 

 

 

 

 

: 

 

 

 

CC BY-NC-SA

XSLT 209 

 

 

 

3.2.32 Les variables 

Il est possible, en XSLT, de définir des variables, mais elles sont « immutables » (« dont 

la valeur ne peut être modifiée »). On peut se demander, à juste titre, si les mots 

variables et immutables vont bien ensemble, mais c’est ainsi que les inventeurs du 

XSLT se sont exprimés. Pour définir une variable nommée « test », on utilise l’élément 

« ». La variable contiendra alors le résultat 

de l’expression XPath contenue dans l’attribut « select ». L’exemple suivant peut 

être utilisé pour afficher le contenu de tous les éléments « produit » immédiatement 

contenus dans l’élément racine. 

 

 

 

 

 

 

 

On peut aussi définir la valeur de la variable en omettant l’attribut « select » et en 

ajoutant du contenu à l’élément « xsl:variable ». Ce contenu pourrait comprendre du 

XSLT. 

 

 

 

x 

 

 

 

 

 

On peut déclarer la variable localement au sein d’un élément template : 

 

 

CC BY-NC-SA


 

 

x 

 

 

 

 

3.2.33 Les paramètres 

Un fichier XSLT peut être utilisé comme un programme dans la mesure où on peut lui 

passer des paramètres. Rappelons qu’on appelle un fichier XSLT « xslt.xml » à partir 

d’un fichier XML qu’on veut transformer de cette manière : 

 

 

 

10.10 

Jean Rochond 


 

On peut enrichir cet appel avec les instructions « xslt-param » comme dans cet exemple. 

 

 

 

 

 

10.10 

Jean Rochond 


 

Selon votre processeur XSLT, il peut y avoir d’autres façons de passer des paramètres 

à une feuille de style XSLT. 

On reçoit alors les paramètres avec un élément « xsl:param ». L’attribut « select » est 

utilisé pour spécifier une valeur par défaut. 

 

 

CC BY-NC-SA

XSLT 211 

 

 

 

 

 

Facture de 

 

 

Ceci est 

une facture pour 

de $ pour: 

. 

 

 

 

 

On peut aussi passer des paramètres aux éléments « xsl:template » avec les éléments 

« xsl:call-template » comme dans cet exemple qui est une façon équivalente, mais plus 

compliquée, de formater notre document XML de type « facture » . 

 

 

 

 

 

 

 

 

 

 

 

Facture de 

 

 

Ceci est 

une facture pour 

de $ pour: 

. 

 

 

CC BY-NC-SA


 

 

On peut aussi charger des documents distants avec la fonction XSLT « document » , 

cette instruction donne une copie du document situé à l’adresse @href : . (L’élément « xsl:copy-of » sert ici à faire une copies des 

nœuds contenus dans le document distant.) Elle est cependant sujette à des contraintes 

de sécurité lorsqu’on l’utilise dans un navigateur : il n’est pas permis de charger des 

documents provenant d’autres serveurs que le serveur d’origine. 

3.2.34 Générer un commentaire 

Il arrive qu’on veuille produire un commentaire dans la sortie XML. Rien de plus 

simple ! Il suffit d’utiliser l’instruction xsl:comment comme dans cet exemple : 

 

 

Ceci est un commentaire. 

 

Le résultat devrait ressembler à ceci : 

 

 

3.2.35 Créer des éléments dynamiquement avec « xsl:element » 

Il est parfois utile de créer dynamiquement un élément avec « xsl:element » et de créer 

des attributs avec « xsl:attribute ». Dans l’exemple suivant, on va créer un élément dont 

le nom nous est fourni par un paramètre. 

 

 

 

 

 

 

bleu 

 

CC BY-NC-SA

XSLT 213 

 

 

 

3.2.36 Copier des nœuds avec « xsl:copy » et « xsl:copy-of » 

Il est parfois nécessaire de dire au XSLT qu’on souhaite tout simplement recopier le 

nœud courant dans le document sortant. L’élément « xsl:copy » copie l’élément (seul, 

sans ses attributs mais avec son espace de noms) alors que l’élément « xsl:copy-of » 

permet de copier un élément ainsi que tous les nœuds qu’il contient. XSLT ne transforme 

pas les nœuds ainsi copiés, ils sont insérés dans le résultat directement. Par 

exemple, ce document XSLT va créer une copie intégrale du document: 

 

 

 

 

 

 

Dans le cas où l’on sélectionne plus d’un élément, notamment avec une expression du 

type nom|prenom, tous les éléments sont copiés l’un après l’autre. Ce comportement 

diffère de l’instruction value-of qui n’extrait le contenu textuel que du premier élément 

rencontré. 

Par contre, si on ne souhaite qu’un document XML qui contient le même élémentracine, 

mais sans le contenu de l’élément racine, on utilisera plutôt un élément 

« xsl:copy », comme ceci : 

 

 

 

 

 

 

Naturellement, on peut même définir le contenu de l’élément copié à l’aide d’un modèle 

: 

CC BY-NC-SA


 

 

 

 

x 

 

 

 

Si on souhaite ne copier qu’une partie du contenu de l’élément ainsi reproduit, par 

exemple ses attributs, on peut utiliser copy-of : 

 

 

 

 

 

x 

 

 

 

3.2.37 Union, intersection et différence en XSLT 

Nous avons vu que le symbole « | » nous permet d’obtenir l’union de deux expressions 

XPath. Prenons l’exemple de ce document : 

 

 

 

 

 

 

L’expression « //*[@s="1"] » représente les éléments a et b, l’expression 

« //*[@t="1"] » représente les éléments b et c, alors que l’expression 

« //*[@s="1"]|//*[@t="1"] » représente les éléments a,b,c (une union de 

« //*[@s="1"] » et « //*[@t="1"] »). 

CC BY-NC-SA

XSLT 215 

Supposons maintenant que nous désirions obtenir les éléments qui satisfont « @s="1" » 

et « @t="1" » : on veut calculer l’intersection entre « //*[@s="1"] » et « //*[@t="1"] ». 

On pourrait, bien sûr, obtenir ce résultat avec « //*[@s="1" and @t="1"] », mais il 

existe une autre façon de le faire qui est d’application plus générale. Supposons que les 

résultats des expressions « //*[@s="1"] » et « //*[@t="1"] » sont déjà stockés dans les 

variables a1 et a2 respectivement. Alors l’expression « $a1[count(.|$a2)=count($a2)] » 

sélectionne l’élément b (ou « //*[@s="1" and @t="1"] »). Ce motif particulier calcule 

l’intersection entre le contenu des variables a1 et a2. Pour le comprendre, il suffit de 

réaliser que la condition « count(.|$a2)=count($a2) » n’est vraie que pour les nœuds 

appartenant déjà à l’ensemble a2. 

Supposons maintenant que l’on souhaite trouver les éléments qui satisfont « @s="1" » 

mais pas « @s="1" », c’est-à-dire l’élément a. En fait, on souhaite calculer la différence 

entre deux ensembles (« //*[@s="1"] » et « //*[@t="1"] »). On pourrait 

obtenir ce résultat avec l’expression « //*[@s="1" and not(@t="1")] », mais encore 

une fois, il existe un motif plus général: « $a1[count(.|$a2)!=count($a2)] » ou 

« //*[@s="1"][count(.|//*[@t="1"])!=count(//*[@t="1"])] ». Pour comprendre cette 

expression, il suffit de réaliser que si et seulement si un nœud x n’appartient pas à 

a2, alors l’expression « count(x|$a2)!=count($a2) » sera vraie. 

3.2.38 Espaces de noms 

Les espaces de noms sont supportés et ne posent pas de problème. Il suffit de définir 

les préfixes, comme on le fait habituellement. Par exemple, considérons le code XML 

suivant : 

 

 

 

 

Réjean Tremblay 

 

 

Pour afficher le nom de l’étudiant, il suffira d’utiliser le document XSLT suivant : 

 

 

 

 

 

 

 

CC BY-NC-SA


 

 

 

 

Observons que l’attribut « match="nom" » ne s’applique pas à l’élément « nom » 

dans l’espace de noms « http://www.mondomaine.com/ », tel qu’il apparaît dans notre 

document XML : il est obligatoire d’utiliser un préfixe correspondant au bon espace 

de noms. Tout comme « match="*" » permet de sélectionner tous les éléments, 

« match="n:*" » permet de sélectionner tous les éléments qui sont dans un espace de 

noms donné. 

3.2.39 Les axes 

Par défaut, l’expression XPath « nom » désigne les éléments « nom » qui sont des 

enfants du nœud courant. On peut aussi écrire « child::nom ». De la même manière, 

« nom[2] » ou « child::nom[2] » désigne le second enfant du nœud courant. Il est 

possible de changer ce comportement en choisissant un axe différent. 

– « child » : il s’agit de l’axe par défaut, « child::nom[3] » désigne le troisième élément 

« nom » enfant du nœud courant. 

– « parent » : l’axe « parent » est pratiquement inutile, « parent::nom » désigne l’élément 

parent si celui-ci se nomme « nom ». En général, il est plus simple d’utiliser la 

syntaxe « .. » qui est équivalente à « parent::node() ». 

– « attribute » : la syntaxe « attribute:: » n’est pas utilisée, on préfère la notation 

« @nom » qui signifie la même chose que « attribute::nom ». 

– « ancestor » : la syntaxe « ancestor::nom » désigne les éléments de nom « nom » dans 

lesquels le nœud courant est contenu. On peut tester si le nœud courant est contenu 

dans un paragraphe avec la syntaxe .... 

– « ancestor-or-self » : idem que l’axe ancestor exception faite que l’on inclut le 

nœud courant, on pourrait donc tester si nœud courant est contenu dans un paragraphe 

ou s’il est lui-même un paragraphe avec la syntaxe .... 

– « preceding-sibling » : cet axe consulte en séquence les frères du nœud courant, 

c’est-à-dire les nœud ayant le même parent, qui apparaissent avant le nœud courant. 

Par exemple, « preceding-sibling::nom[2] » cherche le second élément-frère apparaissant 

avant le nœud courant. 

– « following-sibling » : voir l’axe « preceding-sibling », mais à l’envers (après le 

nœud courant). 

– « preceding » : cet axe est similaire à « preceding-sibling », mais on traverse tous les 

nœuds qui se sont terminés avant nœud courant. Par exemple, « preceding::nom[2] » 

cherche le second élément apparaissant avant le nœud courant, même s’il n’a pas le 

même parent. 

CC BY-NC-SA

XSLT 217 

– « following » : voir l’axe « preceding », mais à l’envers. 

– « descendant » : voir l’axe « ancestor », mais à l’envers. 

– « descendant-or-self » : voir l’axe « ancestor-or-self », mais à l’envers. 

3.2.40 L’étude d’un exemple: docbook.xslt 

Lors du travail 3, je vous ai demandé d’utiliser un fichier XSLT appelé docbook.xslt qui 

transforme des documents DocBook simple en HTML. Vous êtes maintenant en mesure 

d’analyser et de comprendre cet exemple. Nous allons passer en revue brièvement les 

éléments « xsl:template » qu’il contient. 

Le premier élément « xsl:template » sert à capturer l’élément « book ». Comme il 

s’agit de l’élément-racine, on en profite pour produire les éléments « html », « head » 

et « body ». Le contenu de l’élément « head » sera rempli par l’élément « xsl:template » 

traitant l’élément DocBook « bookinfo ». On affiche immédiatement le prénom et le 

nom de l’auteur à l’aide des expressions XPath « bookinfo/author/firstname » et « bookinfo/author/surname 

». Notez l’utilisation de l’élément pour 

produire un espace entre le nom et le prénom. En effet, sans cet élément, il n’y aurait 

pas d’espace puisque les espaces et retours de charriot sont ignorés dans les fichiers 

XSLT. Le reste du document est produit avec les deux éléments « xsl:template » traitant 

les éléments « chapter » : on utilise le l’attribut mode « tdm » pour produire la 

table des matières, et le reste du document est produit avec le traitement des éléments 

« chapter » par défaut (sans attribut mode). 

 

 

 

 

 

 

 

© 

Table des matières 

 

 

 

 

L’élément « xsl:template » traitant l’élément DocBook « bookinfo » est simple : l’expression 

XPath « title » permet de trouver le titre du document puisqu’un élément 

« title » doit être présent dans tout élément DocBook « bookinfo ». Comme on l’a fait 

précédemment, on trouve le prénom et le nom de l’auteur, mais cette fois-ci, avec les 

expressions XPath « author/firstname » et « author/surname » puisque nous sommes 

maintenant au sein d’un élément « bookinfo ». 

 

CC BY-NC-SA


 

par 

 

 

 

Les élément « xsl:template » avec attribut mode génèrent la table des matières. Les 

éléments « xsl:number » permettent de numéroter automatiquement les chapitres et 

sections. Afin de générer des hyperliens permettant de naviguer dans le document à 

partir de la table des matières, on utilise des fragments générés à partir de la fonction 

XSLT « generate-id ». Lorsque nous générons le contenu du document lui-même, on 

utilise à nouveau la fonction XSLT « generate-id » pour placer des ancres dans le 

document au bon endroit. L’avantage de la fonction XSLT « generate-id » est qu’elle 

permet de générer facilement un identifiant unique pour chaque paragraphe. 

 

 

. 

 

 

 

 

 

. 

 

 

 

 

Les élément « xsl:template » sans attribut mode génèrent le document lui-même. La 

principale différence avec la génération de la table des matières est la présence de 

l’élément qui traite le contenu des éléments « section ». 

 

Chapitre 

. 

 

 

 

 

 

 

CC BY-NC-SA

XSLT 219 

. 

 

 

 

 

 

 

 

Le traitement des éléments DocBook « itemizedlist », « orderedlist » et « listitem » est 

simple : il suffit de les convertir en éléments HTML « ul », « ol » et « li » respectivement. 

 

 

 

 

 

 

 

 

 

 

Les éléments DocBook « programlisting » sont convertis en éléments HTML « pre » 

(préformaté). 

 

 

 

 

 

 

Les éléments DocBook « para » sont convertis en éléments HTML « p » sauf lorsqu’ils 

sont au sein d’un élément DocBook « listitem ». 

 

 

 

 

 

 

CC BY-NC-SA


 

 

 

Les éléments DocBook « title » ne doivent pas être traités directement lorsqu’on les 

rencontre. 

 

Comme vous pouvez le constater, en décomposant un document XSLT complexe, on 

arrive facilement à en expliquer le fonctionnement. C’est d’ailleurs un avantage de la 

programmation déclarative de pouvoir être ainsi décomposée et expliquée. 

3.2.41 Activité suggérée 

Essayez de refaire les exemples avec le moteur XSLT de Firefox. Vous devrez ajouter 

les éléments « html » et « body » lorsqu’ils ont été omis. Essayez également de modifier 

les exemples pour vous assurer d’avoir bien compris. 

Enfin, pour mieux comprendre le XSLT, faites quelques exercices exploratoires. Vous 

pouvez consulter les articles de mozilla.org sur XSLT (http://developer.mozilla.org/en/ 

docs/XSLT) et XPath (http://developer.mozilla.org/en/docs/XPath). 

Pour avoir une vue d’ensemble, consultez le pense-bête XSLT. 

3.2.42 Autres moteurs XSLT 

Votre navigateur supporte XSLT, mais si vous désirez un moteur XSLT qui ne dépende 

pas d’un navigateur, je vous suggère 4Suite (http://www.4suite.org/) ou Xalan (http:// 

xml.apache.org/xalan-j/). Si vous avez le temps d’installer un tel moteur, vous pourrez 

sans doute plus rapidement faire les travaux et refaire les exemples de cette leçon, mais 

l’utilisation de Firefox est suffisante. 

3.2.43 Pour voir le résultat de la transformation XSLT 

Avec Firefox .2.0 ou mieux, on peut voir le résultat de la transformation XSLT en enregistrant 

le fichier: il faut aller dans le menu « Fichier » puis sélectionner « Enregistrez 

sous ». Normalement, on pourra alors enregistrer le fichier XML en fichier HTML (si 

la transformation donne un fichier HTML). On peut ouvrir le fichier HTML avec un 

éditeur comme Bloc-note pour voir le résultat. 

CC BY-NC-SA

XSLT 221 

3.2.44 SVG et XSLT 

Une des applications intéressantes du XSLT est de transformer un document en image. 

Par exemple, étant donné les données d’une entreprise, on pourrait automatiquement 

générer un histogramme en SVG. 

3.2.45 XPath, XPointer et XLink 

En présentant le XSLT, nous avons couvert les expressions XPath qui nous permettent 

de sélectionner des nœuds dans des documents XML. D’autres technologies XML utilisent 

XPath comme XLink et XPointer. 

XPointer est tout simplement une façon d’ajouter à un URI une expression XPath 

pour permettre de représenter un lien vers une partie d’un document XML. On 

ajoute un fragment de la forme « #xpointer(...) » à l’URI où les trois petits points 

sont remplacés par une expression XPath. Par exemple, si vous voulez représenter 

le premier élément « cours » d’un document XML, vous pouvez utiliser la syntaxe 

« http://x.com/doc.xml#xpointer(//cours[1]) ». Si vous omettez l’URI, par défaut, le 

document XML dans lequel se trouve l’expression XPointer est sélectionné. Les navigateurs 

ne supportent pas encore correctement XPointer. 

XLink est une généralisation des hyperliens du HTML pouvant être utilisé dans tous 

les documents XML. On utilise XLink surtout pour mettre des hyperliens dans des 

images SVG. L’espace de noms pour XLink est « http://www.w3.org/1999/xlink » et 

on l’utilise surtout avec l’attribut « href ». Dans la figure SVG suivante, le texte « INF 

6450 » est un hyperlien vers l’URI « http://www.teluq.ca/inf6450 ». 

Voici le code de la figure. 

 

 

 

 

 

 


 

 

 

CC BY-NC-SA


 

Voici le rendu de la figure dans votre navigateur avec l’hyperlien. 

3.2.46 XPath 2.0 

Une nouvelle version de XPath est disponible (XPath 2.0). À part quelques exceptions, 

tout ce qui fonctionnait en XPath 1.0, fonctionne toujours en XPath 2.0. Cependant, 

XPath 2.0 ajoute de nombreuses fonctions et opérateurs qui simplifient la vie du 

programmeur tels que empty, exists, intersect, except (pour calculer le complément), 

deep-equal (pour tester l’égalité entre deux séquences), index-of, reverse, subsequence, 

insert-before, remove, distinct-values, avg, max, min, etc. Alors que XPath 1.0 ne traite 

que des nombres, des chaînes de caractères, des valeurs booléennes et des ensembles de 

nœuds, XPath 2.0 introduit la notion de séquence et plusieurs autres types de données 

pour noter les notes, la durée, les entiers, les nombres à virgule flottante, etc. XPath 

2.0 supporte aussi les expressions régulières avec les fonctions matches, replace, et tokenize. 

XPath 2.0 intègre maintenant la fonction « document » qui était une fonction 

XSLT. 

XPath 2.0 comprend maintenant un syntaxe if/then/else comme dans cet exemple : « if 

( @sexe eq ’m’ ) then ’Monsieur’ else ’Madame’ ». On peut aussi utiliser des boucles : 

CC BY-NC-SA

XSLT 223 

« for $i in //etudiant return $i/note ». On peut vérifier si au moins un (some) ou tous 

(every) les éléments d’une séquence satisfont une condition: « every $i in //etudiant 

satisfies $i/note > 0 » ou « some $i in //etudiant satisfies $i/note < 100 ». En somme, 

XPath 2.0 permet d’effectuer plusieurs traitement qui n’étaient possible qu’avec des 

instructions XSLT auparavant. 

3.2.47 XLT 2.0 

Une nouvelle version du XSLT est disponible, nommée XLT 2.0. Elle ajoute notamment 

la possibilité de générer plusieurs documents plutôt qu’un seul avec l’instruction 

xslt:result-document. On peut aussi traiter non seulement des fichiers XML, mais aussi 

d’autres types de fichiers dont les fichiers CSV (comma-separated values) générés par 

les chiffriers électroniques et bases de données. L’instruction « xsl:analyze-string » 

permet de prendre appui sur les nouvelles possibilités du traitement des chaînes de caractères 

de XPath 2.0. L’instruction « xsl:function » permet quant à elle de définir de 

nouvelles fonctions qui pourront être utilisées au sein des expressions XPath. L’instruction 

« xsl:for-each-group » permet de visiter les nœuds par groupes : on peut ainsi 

visiter tous les éléments etudiant en les regroupant selon la valeur de leur attribut nom. 

Elliotte Rusty Harold a publié une page sur XSLT 2.0 qui présente quelques exemples. 

3.2.48 XQuery 

XSLT peut servir pour extraire des informations d’un document XML. On peut trouver 

tous les noms des étudiants répondant à certains critères. Dans un sens, XSLT peut être 

utilisé comme langage dans le contexte des bases de données. Cependant, pour cette fin 

spécifique, un nouveau langage appelé XQuery a été proposé. La syntaxe du XQuery 

est un mélange de XPath et de SQL et ressemble davantage à ce que les spécialistes 

des bases de données connaissent bien. 

Pour tester les requêtes XQuery, Saxon est un outil pratique écrit en java. Pour utiliser 

Saxon, chargez d’abord le fichier saxon9.jar. Vous devez mettre votre requête XQuery 

dans un fichier texte (tel que « query ») et invoquez Saxon comme ceci : 

java -cp saxon9.jar net.sf.saxon.Query query 

Dans cet exemple, il faut que les fichiers saxon9.jar et query soient dans le dossier 

où vous lancez la commande. Le fichier query doit contenir une requête XQuery. Une 

requête XQuery n’est pas du XML. 

Pour rendre nos exemples plus concrets, supposez que le fichier qui se trouve à l’URI 

http://universite.com/etu.xml soit celui-ci : 

 

 

Laroche 

Pierre 

CC BY-NC-SA


inscrit 

 

INF 6460 

54 

 

 


44 

 

 

 

Aaron 

Jean 

inscrit 

 

INF 6460 

56 

 

 


46 

 

 

 

Pouf 

Jean 

non-inscrit 

 

 

Vous pouvez créer un fichier etu.xml sur votre disque dans le même dossier que le 

fichier query, et remplacer partout l’URI par le nom du fichier (tel que « etu.xml »). 

Parce que XQuery, tout comme XSLT 2.0, s’appuie sur XPath 2.0, il est facile de calculer 

la liste des cours : 

for $s in distinct-values(doc("etu.xml")//sigle) 

return $s 

Cette requête donnera « INF 6460 INF 6450 ». 

Voici un exemple de requête XQuery pour extraire d’un document XML tous les étudiants 

inscrits : 

 

{let $inscription := "inscrit" 

for $b in doc("http://universite.com/etu.xml")/liste/etudiant 

where $b/statut = $inscription 

order by $b/nom ascending 

CC BY-NC-SA

XSLT 225 

return 

{ $b/prenom } 

{ $b/nom } 

} 

 

Cet exemple est une requête de type FLWOR parce qu’elle ne contient que des instructions 

« for », « let », « where », « order by », et « return ». L’instruction « for » sert 

à définir une boucle, l’instruction « where » sert à poser une condition, l’instruction 

« order by » permet de trier le résultat, alors que l’instruction « return » définit le résultat. 

L’instruction « let » permet de définir une constante. Notez que XQuery utilise les 

accolades pour distinguer les requêtes XQuery et XPath du texte. La requête considère 

tous les éléments etudiant contenus dans l’élément-racine liste, pour chacun d’entre 

eux, elle vérifie qu’il contient un élément statut contenant le texte « inscrit », puis elle 

donne la liste des noms et prénoms triée selon le nom. Voici quel sera le résultat : 

 

 

Jean 

Aaron 

 

 

Pierre 

Laroche 

 

 

On peut attribuer un compteur aux nœuds : 

 

{ 

for $b at $pos in doc("http://universite.com/etu.xml")/liste/etudiant 

order by $b/nom descending 

return 

$pos - 

{ $b/prenom } 

{ $b/nom } 

 

} 

 

Le résultat sera alors : 

 

3- 

Jean 

Pouf 

 

1- 

CC BY-NC-SA


Pierre 

Laroche 

 

2- 

Jean 

Aaron 

 

 

On peut combiner les requêtes FLWOR, comme dans cet exemple : 

 

{for $e in doc("http://universite.com/etu.xml")//etudiant 

return 

 

{ for $v in $e/cours return 

{number($v/note)} 

} 

 

} 

 

Cette requête va considérer chaque élément etudiant du document XML et créer une 

liste de notes obtenues pour cet étudiant, dans ce cas, le résultat sera : 

 

 

54 

44 

 

 

56 

46 

 

 

 

L’expression suivante va calculer la moyenne de notes (50) : 

 

avg( 

for $n in doc("http://universite.com/etu.xml")//note 

return $n 

) 

 

Par défaut, les documents XQuery utilisent le jeu de caractères Unicode UTF-8. On 

peut stipuler un jeu de caractères différent dans la déclaration XQuery optionnelle 


CC BY-NC-SA

XSLT 227 

xquery version "1.0" encoding "utf-8"; 

for $s in distinct-values(doc("etu.xml")//sigle) 

return $s 

Certains moteurs de bases de données comme MonetDB ou eXist supportent les requêtes 

XQuery. Il y a aussi d’excellents tutoriels sur le web. Elliotte Rusty Harold nous 

offre une excellente page sur XQuery qui résume bien les points essentiels avec des 

exemples. 

3.2.49 XPath versus XSLT 

Les expressions XPath sont très utilisées en XSLT. Apprendre le XSLT, c’est aussi 

apprendre XPath. Par contre, tout ce qui ressemble à une expression XPath, n’est pas 

nécessairement une expression XPath. Par exemple, les fonctions current, document, 

generate-id et key sont des fonctions XSLT qui ne sont pas disponibles en XPath, mais 

qui s’utilisent au sein des expressions XPath. On peut aussi utiliser les expressions 

XPath en Java, en ECMAScript, avec XQuery, etc. Avec XSLT 2.0, il est possible de 

définir ses propres fonctions qui s’utilisent au sein des expressions XPath. 

3.2.50 En terminant 

Le langage XSLT est beaucoup plus riche que ce que nous venons de vous présenter. 

Nous pouvons pratiquement tout faire avec le XSLT. En fait, le XSLT est un langage 

complet (au sens de Turing) et, en principe, tout ce qui peut être fait comme transformation 

en Java, peut être fait en utilisant le XSLT. En pratique, le XSLT est particulièrement 

approprié si nous voulons faire des transformations simples. 

Il est aussi possible d’utiliser le XSLT pour résoudre automatiquement des problèmes 

intéressants. Supposons que vous deviez communiquer avec une institution qui utilise 

aussi le XML, mais avec des fichiers XML légèrement différents. Il est possible qu’une 

simple transformation XSLT permette de transformer les fichiers XML de l’autre institution 

en des fichiers similaires aux vôtres. 

Le XSLT peut sembler un peu déroutant, mais il faut simplement prendre de l’expérience 

avec ce type de programmation. 


– Sal Mangano, XSLT Cookbook, O’Reilly Media, 2006, 751 pages. 

– Jeni Tennison, Beginning XSLT, Apress, 2004, 800 pages. 

CC BY-NC-SA



1. Parmi les suivants, quels sont les documents XSLT corrects Choisissez toutes 

les réponses qui s’appliquent. 

(a) 

(b) 

(c) 

(d) 

 

 

 

 

 

 

 

 

 

 

2. Étant donné le document XML suivant... 

 

 

 

Jean 

Graton 

 

 

et le fichier XSLT suivant... 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA

XSLT 229 

 

 

 

Qu’est-ce qui s’affichera à l’écran 


(a) Jean Graton 

(b) JeanGraton 

(c) Jean Graton 

(d) Jean Graton 

(e) Jean Graton 

(f) Jean Graton 

(g) Rien 

(h) Jean 

(i) Graton 


 

 

 

Jean 

Graton 

 

 


 

 

 

 

 

 

 

 

 

 

 

CC BY-NC-SA


 

 




(b) Jean Graton 




(f) Rien 

(g) Jean 

(h) Graton 


 

 

 

Jean 

Graton 

 

 


 

 

 

 

 

 

 

 




CC BY-NC-SA

XSLT 231 

(b) Jean Graton 




(f) Rien 

(g) Jean 

(h) Graton 


 

 

 

lait 

Je dois acheter beaucoup de lait. 

 

 

pomme de terre 

Même si la pomme de terre est mauvaise pour la santé, 

je dois en acheter beaucoup. 

 

 


 

 

 

 

 

 

 

 

 

 

() 

 

 

CC BY-NC-SA


 



(a) lait (50 $) pomme de terre 

(b) – lait (50 $) 

– pomme de terre (20 $) 

(c) – lait (50 $)Je dois acheter beaucoup de lait. 

– pomme de terre (20 $)Même si la pomme de terre est mauvaise pour la 

santé, je dois en acheter beaucoup. 

6. Qu’est-ce qui décrit le mieux le document XSLT suivant 

 

 

 

 

 

 

 

 

 

 

 

 


(a) Il va produire la liste des balises des documents XML. 

(b) Il va produire des documents vides. 

(c) Il va produire des versions des documents XML, mais sans les balises. 

(d) Ce document XSLT n’est pas valable. 

(e) Ce document XSLT est valable, mais ne pourra pas s’exécuter. 

7. Si on applique le document XSLT suivant... 

 

 

 

CC BY-NC-SA

XSLT 233 

 

 

 

au document XML suivant... 

 

 

INF 102 Introduction avancée 


Un cours d’introduction à l’informatique pour futurs 

ingénieurs. 


Un cours d’introduction à l’informatique pour les 

étudiants en éducation. 

INF 103 Java 

description>Un cours d’introduction au Java 

 

Quel sera le résultat 


(a) Le chiffre « 1 ». 

(b) Le chiffre « 2 ». 

(c) Le chiffre « 3 ». 

(d) Le chiffre « 4 ». 

(e) Un document vide. 


 

 

 

 

 

 


(a) Il donne le nom de tous les éléments dans le document. 

(b) Il donne le nom de tous les éléments et attributs dans le document. 

(c) Il donne le nom de l’élément-racine. 

(d) Il donne le nom de l’élément-racine et de tout attribut qu’il pourrait avoir. 

CC BY-NC-SA



 

 

 

 

 

 


(a) Il donne le contenu textuel (sans les balises) de tous les éléments « cours » 

ou « universite » du document XML. 

(b) Il donne « cours » si l’élément-racine est de type « cours ». 

(c) Il donne « cours » ou « universite », autant de fois qu’il y a d’éléments 

« cours » ou « universite » dans le document, et rien d’autre. 

(d) Il donne « cours » ou « universite », autant de fois qu’il y a d’éléments 

« cours » ou « universite » dans le document, et le contenu textuel de tous 

les autres éléments qui ne sont pas contenus dans un élément « cours » ou 

dans un élément « université ». 


 

 

 

 

 

 


(a) Il donne le nom de tous les éléments contenus dans l’élément-racine. 

(b) Il donne le nom de l’élément-racine. 

(c) Il donne le nom de tous les éléments du document XML. 


 

 

 

[] 

 

CC BY-NC-SA

XSLT 235 

 

 

 

[] 

 


(a) Il donne une liste d’identifiants, un et un seul identifiant pour chaque élément 

du document XML. Il n’y a pas deux identifiants égaux. 

(b) Il donne une liste d’identifiants, chacun étant répété deux fois. 

(c) Il donne une liste d’identifiants dont certains sont répétés deux fois. 


 

 

 

 

 

 

 

 

 

 

 

 

 

 


(a) Il donne le contenu textuel de tous les éléments « nom » immédiatement 

contenus dans des éléments « cours » 

(b) Il donne le contenu textuel de tous les éléments « nom » immédiatement 

contenus dans des éléments « cours », eux-mêmes immédiatement contenus 

dans des éléments « universite ». 

(c) Il donne un document vide. 

(d) Il donne le contenu textuel de tous les éléments « nom » immédiatement 

contenus dans des éléments « cours », eux-mêmes immédiatement contenus 

dans l’élément-racine « universite ». 


CC BY-NC-SA


 

 

 

 

 

 

 

 

 


(a) Il donne le nom de tous les éléments. 

(b) Il donne le nom de l’élément-racine. 

(c) Il donne un document vide. 


 

 

 

 

 

 

 

 


(a) Il donne le document XML original, où les éléments ont tous été remplacés 

par des éléments de nom « a ». 

(b) Il remplace le document XML original par un document ne contenant que 

des éléments « a » sans contenu textuel. 

(c) Il donne le document XML original. 

15. Quelle est la valeur de l’expression XPath « client.nom » Choisissez la bonne 


(a) Une séquence de tous les éléments « client.nom » dans le contexte actuel. 

(b) Tous les éléments « nom » contenus dans les éléments « client » qui se 

trouvent dans le contexte actuel. 

(c) Les éléments « client » qui précèdent le contexte actuel, ainsi que les éléments 

« nom » qui suivent le contexte actuel. 

CC BY-NC-SA

XSLT 237 

16. Quelle est la valeur de l’expression XPath « ./client » Choisissez la bonne réponse 


(a) L’élément « client » qui se trouve dans le contexte actuel. 

(b) Une séquence de tous les éléments « client » dans le contexte actuel. 

(c) Une séquence de tous les éléments et attributs « client » dans le contexte 

actuel. 

17. Quelle est la valeur de l’expression XPath « client » Choisissez la bonne réponse 


(a) L’élément « client » qui se trouve dans le contexte actuel. 

(b) Une séquence de tous les éléments « client » dans le contexte actuel. 

(c) Une séquence de tous les éléments et attributs « client » dans le contexte 

actuel. 

18. Quelle est la valeur de l’expression XPath « /client » Choisissez la bonne réponse 


(a) L’élément « client » voisin de l’élément courant. 

(b) Le premier élément « client » rencontré dans le document. 

(c) L’élément-racine si celui-ci se nomme « client ». 

19. Quelle est la valeur de l’expression XPath « //client » Choisissez la bonne réponse 


(a) Le deuxième élément « client » rencontré. 

(b) La séquence de tous les éléments « client » du document. 

(c) L’élément-racine si celui-ci se nomme « client ». 

20. Quelle est la valeur de l’expression XPath 

« client[current()/@telephone=@telephone] » Choisissez la bonne réponse 


(a) Les éléments « client » dans l’élément courant ayant un attribut « telephone 

». 

(b) Les éléments « client » dans l’élément courant dont l’attribut « telephone » 

a la même valeur que l’attribut « telephone » de l’élément courant. 

(c) Les valeurs des attributs « telephone » de tous les éléments « client » dans 

l’élément courant. 

21. Quelle est la valeur de l’expression XPath « client/*|client/@* » Choisissez la 


(a) Tous les éléments contenus dans des éléments « client » dans le contexte 

actuel. 

(b) Tous les éléments et attributs contenus dans des éléments « client » dans le 

contexte actuel. 

CC BY-NC-SA


(c) L’ensemble des attributs contenus dans des éléments « client » enfant d’éléments 

contenus dans des éléments « client ». 

22. Quelle est la valeur de l’expression XPath « *[@telephone] » Choisissez la 


(a) La valeur de l’attribut « telephone » de l’élément courant. 

(b) L’élément courant s’il contient un attribut « telephone ». 

(c) Tous les éléments dans le contexte courant ayant un attribut « telephone ». 

23. Quelle est la valeur de l’expression XPath « (vendeur/client)[2] » Choisissez la 


(a) Le deuxième élément « client » dans la liste des éléments « client » contenus 

dans des éléments « vendeur ». 

(b) Le deuxième élément « vendeur » dans la liste des éléments « client » 

contenus dans des éléments « vendeur ». 

(c) Le deuxième élément « client » contenu dans un élément « vendeur ». 

24. Quelle est la valeur de l’expression XPath « vendeur/client[2] » Choisissez la 


(a) Le deuxième élément « client » dans la liste des éléments « client » contenus 

dans des éléments « vendeur ». 

(b) Le deuxième élément « vendeur » dans la liste des éléments « client » 

contenus dans des éléments « vendeur ». 

(c) Le deuxième élément « client » contenu dans un élément « vendeur ». 

25. Quelle est la valeur de l’expression XPath « vendeur[2]/client[1] » Choisissez 


(a) Le second élément « client » contenu dans le premier élément « vendeur » 

rencontré. 

(b) Est équivalent à « vendeur/vendeur/client[1] ». 

(c) Le premier élément « client » contenu dans le deuxième élément « vendeur 

». 

26. Est-ce que « //p=//c » et « //c=//z » implique « //p=//z » Choisissez la bonne 


(a) Oui 

(b) Non. 

27. Que signifie XSL Choisissez la bonne réponse parmi les choix suivants. 

(a) eXtensible Stylesheet Language 

(b) eXtensible Style Language 

(c) eXtensible Style Laboratory 

CC BY-NC-SA

XSLT 239 

28. Comment fait-on appel à un fichier XSLT Choisissez la bonne réponse parmi 

les choix suivants. 

(a) 

(b) 

(c) 

29. Que vaut « //p=//p » Choisissez la bonne réponse parmi les choix suivants. 

(a) Vrai 

(b) Faux 

(c) Aucune de ces réponses. 

30. Le XSLT transforme les documents XML en d’autres documents XML. Choisissez 


(a) Vrai 

(b) Faux 

31. Est-ce que « //p!=’jean’ » et « not(//p=’jean’) » ont la même signification Choisissez 


(a) Vrai 

(b) Faux 

32. Le XSLT ne s’applique qu’à des fichiers XML valide. Choisissez la bonne réponse 


(a) Vrai 

(b) Faux 

33. Étant donné le fichier XML suivant. 

 

 

 

Jean 

Coutu 

 

 

Quel sera le résultat de la transformation XSLT suivante 

 

 

 

 

 

 

 

CC BY-NC-SA



(a) Rien du tout 

(b) Jean 

(c) 

Jean 

Coutu 

 

(d) Jean Coutu 


 

 

 

Jean 

Coutu 

 

 


 

 

 

 

 

 

 



(b) Jean 

(c) Jean Coutu 

(d) 

Jean 

Coutu 

 


 

 

 

Jean 

Coutu 

CC BY-NC-SA

XSLT 241 

 

 

Marie 

Vanasse 

 

 

Pierre 

Coutu 

 

 


 

 

 

 

 

 



(b) Jean Coutu 

Marie Vanasse 

Pierre Coutu 

(c) Jean Coutu 


 

 

 

Jean 

Coutu 

 

 

Marie 

Vanasse 

 

 

Pierre 

Coutu 

 

 

CC BY-NC-SA



 

 

 

 

 

 



(b) Jean Coutu 

(c) Pierre Coutu 


 

 

 

Jean 

Coutu 

 

 

Marie 

Vanasse 

 

 

Pierre 

Coutu 

 

 


 

 

 

 

 

 


CC BY-NC-SA

XSLT 243 


(b) 

(c) 

 

Jean 

Coutu 

 

 

Jean 

Coutu 

 

Marie 

Vanasse 

 

38. Est-ce qu’il y a une différence entre ces deux expressions XPath: "vendeur/prenom 

= ’Jean’ and vendeur/nom = ’Coutu’" et "vendeur[prenom = ’Jean’ 

and nom = ’Coutu’]" Choisissez la bonne réponse parmi les choix suivants. 

(a) Non aucune. 

(b) Oui, mais pas toujours. 

(c) Oui, ils sont toujours différents. 

39. Que vaut l’expression XPath « //a[1]=current() » Choisissez la bonne réponse 


(a) Vrai si le nœ courant est le premier élément a rencontré, faux autrement. 

(b) Vrai si le nœ courant est le premier élément a rencontré au sein d’un même 

élément, faux autrement. 

(c) Aucune de ces réponses. 


1. (a) (Bonne réponse) Oui, c’est correct : le résultat sera un document vide 

(contenant un espace). 

(b) Non. Ce n’est pas un document XML bien formé, car il n’y a pas d’élémentracine. 

Un document XSLT doit être un document XML bien formé. 

(c) Non. Bien qu’il s’agisse d’un document XML bien formé, l’élément-racine 

« text » n’est pas autorisé, il devrait être « transform » ou bien « stylesheet 

». 

(d) (Bonne réponse) Oui. Il s’agit d’un document XML bien formé et 

l’élément-racine est « transform », ce qui est autorisé. 

2. (a) (Bonne réponse) Effectivement. Le modèle « employe » sera utilisé, mais 

pas le modèle « prenom ». Il y aura bel et bien un espace entre « Jean » 

et « Graton », parce qu’il y a un retour de chariot entre les éléments « prenom 

» et « nom ». Par défaut, les espaces et les retours de chariot entre les 

CC BY-NC-SA


éléments ne sont pas ignorés dans le document XML qui est traité, mais 

ils le sont dans le document XSLT. Un retour de chariot, en HTML ou 

XHTML, s’affiche à l’écran comme un espace. 

(b) Non. L’instruction « value-of » va reproduire le contenu de l’élément, 

moins les balises, mais en respectant les espaces entre les éléments. Il 

n’y aurait pas d’espace entre les éléments si le document XML avait pris 

le forme « JeanGraton » (sans espace 

entre les deux éléments). 

(c) Non. Le modèle « prénom » n’est pas utilisé. 

(d) Non. Le modèle « employe » sera utilisé; le texte sera donc en caractères 

gras. 

(e) Non. Le modèle « employe » sera utilisé; il n’y aura donc pas d’italique. 

(f) Non. Le modèle « employe » sera utilisé; on n’aura donc pas un mélange 

de texte normal et de texte en caractères gras. 

(g) Non. Le modèle « employe » sera utilisé et « value-of » donnera le contenu 

textuel sans les balises. 

(h) Non. Le modèle « employe » sera utilisé; on n’aura donc pas de texte en 

italique. 

(i) Non. Le modèle « employe » sera utilisé; « value-of » sélectionne tout le 

texte, et non seulement « Graton ». 

3. (a) Non. 

(b) Non. 

(c) Non. 

(d) Non. 

(e) Non. 

(f) Non. 

(g) (Bonne réponse) Effectivement. Le modèle « employe » est appelé et luimême 

appelle le modèle « prenom ». 

(h) Non. 

4. (a) Non. 

(b) Non. 

(c) Non. 

(d) Non. 

(e) (Bonne réponse) Effectivement. Comme il n’y a pas de modèle pour l’élément 

« nom », le modèle par défaut s’applique et le contenu du texte est 

reproduit. Par contre, le modèle « prenom » est utilisé. 

(f) Non. 

(g) Non. 

(h) Non. 

CC BY-NC-SA

XSLT 245 

5. (a) Non. Le modèle « budget » s’applique; il doit y avoir création d’une liste. 

(b) (Bonne réponse) Effectivement. Le modèle « budget » s’applique et il y a 

création d’une liste. 

(c) Non. Les éléments « item » sont traités par le modèle « item » qui n’inclut 

pas l’élément « description ». 

6. (a) Non. Au contraire, car « value-of » enlève toutes les balises. 

(b) Non. Le modèle « b » s’applique. 

(c) (Bonne réponse) Exactement. Le modèle « b » s’applique, après l’application 

du modèle par défaut et du modèle « a ». 

(d) Il s’agit d’un document XSLT valable. 

(e) L’utilisation de « mode » est effectivement dangereuse et peut mener à des 

boucles sans fin, mais ce n’est pas le cas pour ce document. 

7. (a) Le modèle compte le nombre d’éléments « cours » dans l’élément-racine 

et il y a plus d’un élément « cours ». 

(b) Le modèle compte le nombre d’éléments « cours » dans l’élément-racine 

et il y a plus de deux éléments « cours ». 

(c) (Bonne réponse) Comme le modèle « * » ne s’applique qu’à l’élémentracine 

qui contient 3 éléments « cours », le résultat sera effectivement le 

chiffre 3. 

(d) Il y a bien 4 éléments « cours », mais le modèle « * » ne s’applique qu’à 

l’élément-racine qui lui contient 3 éléments « cours ». 

(e) Non. L’instruction « » sera exécutée 

et le résultat doit être un nombre. 

8. (a) Le modèle « * » ne s’applique qu’à l’élément-racine. 

(b) Le modèle « * » ne s’applique qu’à l’élément-racine et la fonction « name », 

appliquée à un élément, ne donne que le nom de l’élément. 

(c) (Bonne réponse) C’est vrai. Le modèle « * » ne s’applique qu’à l’élémentracine. 

(d) La fonction « name » appliquée à un élément ne donne que le nom de 

l’élément. 

9. (a) Non. Si un élément « cours » ou « universite » est rencontré, seul son nom 

s’affiche. 

(b) 

(c) Non. La règle par défaut s’applique aux autres éléments et leur contenu 

textuel sera affiché. 

(d) (Bonne réponse) Exactement. La règle par défaut s’applique à tous les éléments, 

sauf aux éléments « cours » dont on ne visite pas les nœuds. 

10. (a) Non, car « / » est le nœud-racine (le document lui-même) et non pas 

l’élément-racine. 

CC BY-NC-SA


(b) (Bonne réponse) Effectivement, car « / » est le nœud-racine (le document 

lui-même) qui ne contient qu’un seul élément : l’élément-racine. 

(c) Non. Comme nous avons une règle qui est appliquée au nœud-racine, le 

traitement du processeur XSLT va s’arrêter immédiatement après l’application 

du seul modèle contenu dans le document XSLT. 

11. (a) Non. À cause de l’utilisation du « mode », certains identifiants sont répétés 

deux fois. 

(b) Non. Pour l’élément-racine, il n’est pas répété deux fois. 

(c) (Bonne réponse) Oui. Ils sont tous répétés deux fois, sauf pour l’élémentracine. 

12. (a) Non. Si un élément « cours » était contenu dans un autre élément « cours », 

il ne serait jamais visité. 

(b) Non. Si l’élément « universite » n’est pas l’élément-racine, il ne sera jamais 

visité. 

(c) Seulement si les éléments « cours » rencontrés dans les éléments « universite 

» n’ont pas de contenu textuel dans leurs éléments « nom ». 

(d) (Bonne réponse) Effectivement. Il n’y a qu’un seul cas où d’autres éléments 

que l’élément-racine sont visités et c’est lorsque l’élément-racine est l’élément 

« universite ». 

13. (a) (Bonne réponse) Effectivement, car « . » n’est que l’élément courant (donc 

un ensemble d’un seul élément); « count(.) » vaut donc « 1 ». 

(b) Oui, mais aussi le nom des autres éléments. 

(c) Comme « count(.) » vaut toujours « 1 », c’est plutôt le nom de tous les 

éléments qui est donné. 

14. (a) Non. Le contenu textuel ne sera jamais modifié. 

(b) (Bonne réponse) Effectivement. Le nom des éléments originaux est donné 

par la valeur de l’attribut « valeur ». 

(c) Absolument pas : il n’y a plus que des éléments « a ». 

15. (a) (Bonne réponse) Effectivement. Le point « . » perd ici sa signification de 

« contexte actuel », car il fait partie d’une chaîne de caractères désignant 

un nom d’élément. 

(b) Non, ce serait « nom/client ». 

(c) Cette explication n’a pas de sens. 

16. (a) Il pourrait y avoir aucun ou plusieurs éléments « client ». 

(b) (Bonne réponse) Effectivement, le contexte pouvant être l’élément courant, 

par exemple. La séquence d’éléments peut être vide. 

(c) Non. Les attributs de nom « client » s’obtiennent avec la syntaxe 

« @client ». 

17. (a) Il pourrait y avoir aucun ou plusieurs éléments « client ». 

CC BY-NC-SA

XSLT 247 

(b) (Bonne réponse) Effectivement, le contexte pouvant être l’élément courant, 

par exemple. La séquence d’éléments peut être vide. On note que c’est la 

même signification que pour l’expression XPath « ./client ». 

(c) Non. Les attributs de nom « client » s’obtiennent avec la syntaxe 

« @client ». 

18. (a) Non, c’est plutôt vers l’élément-racine qu’on pointe. 

(b) Ce serait plutôt « (//client)[1] ». 

(c) (Bonne réponse) Vrai. Il retourne un ensemble vide dans le cas contraire. 

19. (a) Non, ce serait plutôt « client[2] ». 

(b) (Bonne réponse) Effectivement. S’il n’y en a pas, cela donne un ensemble 

vide. 

(c) Non, ce serait plutôt « /client ». 

20. (a) Non, ce serait plutôt « client[@telephone] ». 

(b) (Bonne réponse) Effectivement. On pourrait aussi écrire cette expression 

« client[current()/@telephone=./@telephone] ». Il s’agit d’un exemple où 

« current() » n’a pas la même valeur que « . ». 

(c) Ce serait plutôt « client/@telephone ». 

21. (a) Ce serait alors tout simplement « client/* ». 

(b) (Bonne réponse) Effectivement. S’il n’y a rien qui correspond, un ensemble 

vide est donné. 

(c) Ce serait alors « client/*/client/@* ». 

22. (a) Ce serait tout simplement « @telephone ». 

(b) Ce serait plutôt « .[@telephone] ». 

(c) (Bonne réponse) Effectivement, ou un ensemble vide si ça ne s’applique 

pas. 

23. (a) (Bonne réponse) Effectivement. S’il n’y a pas un tel élément, un ensemble 

vide est donné. 

(b) Non, un élément « client » est donné. 

(c) Non, ce serait alors « vendeur/client[2] ». 

24. (a) Non, ce serait plutôt « (vendeur/client)[2] ». 

25. (a) 

(b) Non, un élément « client » est donné. 

(c) (Bonne réponse) 

(b) Non. Ce type d’abréviation n’existe pas en XPath. 

(c) (Bonne réponse) Effectivement. Si cet élément n’existe pas, un ensemble 

vide est obtenu. 

26. (a) La première égalité est vraie s’il y a un élément p dont le contenu est égal 

au contenu d’un élément c, et la seconde est vraie s’il y a un élément de c 

qui est égal à un élément z, ce qui n’implique pas qu’il existe un élément p 

qui soit égal à un élément z 

CC BY-NC-SA




(b) Non. 

(c) Non. 

28. (a) Non. 


(c) Non. 

29. (a) Seulement s’il existe au moins un élément p dans le document. 

(b) Seulement s’il n’existe pas d’élément p dans le document. 

(c) (Bonne réponse) Effectivement. L’expression //p donne une liste d’éléments. 

La comparaison entre deux listes est vraie s’il existe au moins un 

élément dans la première liste égal à un élément dans la seconde liste. Cela 

est vrai si et seulement s’il y a au moins un élément p. 

30. (a) Non. Le XSLT n’a pas à produire du XML. On peut déclarer que l’on 

souhaite produire du texte avec une telle instruction : . 


31. (a) Non. La première expression est vraie s’il y a un élément p dont le contenu 

est différent de ’jean’, alors que la seconde est vraie seulement si tous les 

éléments sont est différents de ’jean’. 


32. (a) Non. Il suffit que le fichier XML soit bien formé. 


33. (a) Non. 

(b) La variable sélectionne plutôt l’élément vendeur. 

(c) Il s’agit bien du contenu de la variable, mais l’instruction value-of va extraire 

le contenu du texte. 

(d) (Bonne réponse) Correct. 

34. (a) Non. 

(b) La variable sélectionne plutôt l’élément vendeur. 

(c) Non, ce n’est pas l’effet de l’instruction copy-of. 

(d) (Bonne réponse) Effectivement, l’instruction copy-of donne une copie intégrale 

du contenu de la variable. 

35. (a) Non. 

(b) Ce n’est pas l’effet de l’instruction value-of. 

(c) (Bonne réponse) Effectivement, seul le contenu textuel du premier élément 

vendeur sera donné. 

36. (a) Non. 

CC BY-NC-SA

CSS 249 

(b) Non, seul le dernier élément vendeur est sélectionné, car lui seul est précédé 

par un élément vendeur ayant un sous-élément nom de même valeur. 

(c) (Bonne réponse) Effectivement, seul le dernier élément vendeur est sélectionné. 

37. (a) Non. 

(b) Non, le deuxième élément est aussi sélectionné. 

(c) (Bonne réponse) Effectivement, le dernier élément n’est pas sélectionné. 

38. (a) Non. 

(b) Non. Ils sont toujours différents, mais si on les utilise dans une expression 

conditionnelle (xsl:if), ils peuvent être équivalents. 

(c) (Bonne réponse) Effectivement, la première est vraie si on trouve un élément 

vendeur contenant un élément prenom contenant le texte Jean et un 

élément nom contenant le nom Coutu, sinon elle est fausse. La seconde expression 

sélectionne les éléments correspondants à ce critère s’ils existent. 

39. (a) Non. L’égalité compare plutôt le contenu des éléments, pas la position dans 

le document. 

(b) Non. L’égalité compare plutôt le contenu des éléments, pas la position au 

sein d’un élément. 

(c) (Bonne réponse) Effectivement, l’expression n’a la valeur vraie que si l’élément 

courant est un élément « a » ayant le même contenu que le premier 

élément « a » dans le document. 

3.3 CSS 


Utiliser des transformations XSLT et des instructions CSS. 



sur les CSS (Cascading StyleSheets). 

3.3.3 Qu’est-ce que les CSS 

La norme CSS a d’abord été proposée par Håkon Lie du CERN en Suisse en 1994 

(environ 4 ans après l’apparition de la première page web). Cette norme a été acceptée 

comme recommandation officielle du W3C deux ans plus tard, soit en 1996, et la seconde 

version (CSS 2.0) est devenue une recommandation du W3C l’année suivante, 

CC BY-NC-SA


soit en 1997. Une troisième version est en développement. À l’origine, les instructions 

CSS étaient destinées uniquement à indiquer aux navigateurs comment présenter 

le HTML (couleurs, polices, etc.); on s’est vite rendu compte qu’on pouvait aussi 

l’appliquer au XML et on considère maintenant les CSS comme une technologie qui 

s’applique autant au HTML qu’au XML (et aussi, évidemment, au XHTML). 

Nous avons vu que le XSLT permettait de transformer du XML en HTML pour l’affichage 

dans un navigateur. En général, le XSLT permet de transformer tout document 

XML en un autre format (HTML, XML ou autre). 

Un fichier CSS est beaucoup plus limité dans la mesure où il ne transforme pas le document 

XML. Il permet seulement de spécifier comment le contenu du document XML 

sera affiché. Le fichier XSLT est un outil de transformation, alors que le fichier CSS 

est un outil de formatage. Un document CSS permet de rendre un document XML plus 

lisible. D’un autre côté, le fichier CSS permet de contrôler avec beaucoup de finesse 

la présentation du document XML, alors qu’il peut être difficile et fastidieux d’obtenir 

le même résultat en XSLT, sans utiliser les CSS. Les fichiers CSS tendent aussi à être 

plus simples que les fichiers XSLT; il peut donc être plus facile de les modifier et de 

les garder à jour. Finalement, on peut utiliser à la fois des fichiers CSS et des fichiers 

XSLT, en combinant les avantages des deux (présentation et transformation). 

3.3.4 Point de vue critique 

CSS est un langage déclaratif relativement limité. Il n’est pas possible de définir des 

variables, des fonctions ou de faire de l’arithmétique en CSS. On peut, par contre, 

redéfinir à volonté des règles, ce qui peut rendre le comportement final difficile à comprendre 

pour un humain. Il n’est pas facile, en CSS, de détecter le navigateur utilisé 

alors que tous les navigateurs ne traitent pas les règles de la même façon. 

3.3.5 Notions de base 

Pour l’essentiel, le langage CSS prend la forme d’une succession d’affirmations de la 

forme élément propriété: valeur; autrepropriété: valeur;. Il s’agit d’une syntaxe très 

simple. 

Supposons un document XML comme celui-ci : 

 

 

 

Jean Rochond 

10.10 


 

 

Madeleine Bédard 

CC BY-NC-SA

CSS 251 

20.10 

Achat d’un crayon 

 

 

Certains navigateurs affichent le XML brut sans formatage, ce qui n’est pas très accessible. 

D’autres navigateurs affichent le document sans les balises : 

Jean Rochond 

10.10 



20.10 


Ce document XML est difficile à lire, même sans les balises, surtout si vous n’êtes pas 

un expert en XML. Sans le transformer, il est possible de l’afficher avec de la couleur 

ou de l’italique, comme ceci : 

– Jean Rochond 10.10 Achat d’ordinateur 

– Madeleine Bédard 20.10 Achat d’un crayon 

Voilà qui est nettement plus lisible! Nous pouvons obtenir ce résultat à l’aide du fichier 

CSS suivant : 

facture { 

display: block; 

margin-bottom: 30pt; 

} 

montant { 

color: red; 

} 

raison { 


font-style: italic; 

margin-left: 1cm; 

} 

CC BY-NC-SA


Pour vérifier que c’est bien le cas, il suffit de créer un fichier « chap12.css » avec le 

contenu CSS précédent et de modifier le fichier XML en y ajouter une ligne pointant 

vers le fichier CSS (), comme 

ceci : 

 

 

 

 

Jean Rochond 

10.10 


 

 


20.10 


 

 

Si le fichier XML est dans le même répertoire que le fichier CSS, Firefox devrait vous 

présenter le document XML avec le montant en rouge et le commentaire (raison) en 

italique, comme nous l’avons présenté plus haut. 

Examinons maintenant les différentes instructions du fichier CSS. 

– L’instruction « display: block; » déclare que l’élément devrait former son propre 

paragraphe. L’instruction « display: none; » rend l’élément invisible. 

– Les instructions « margin-bottom: 30pt; » et « margin-left: 1cm; » définissent des 

marges en bas et à gauche de 30 points et de 1 cm respectivement. 

– L’instruction « color: red; » affirme que le contenu de l’élément devrait être écrit en 

rouge, alors que « font-style: italic; » nous dit que le texte de l’élément devrait être 

en italique. On pourrait aussi contrôler la couleur de fond avec un instruction comme 

« background-color:red ». 

Dans l’éventualité où nous voulons choisir une couleur très précise, et non les couleurs 

courantes comme « red », « green », « blue », « yellow », « white », « black », etc., nous 

pouvons la spécifier selon sa composition avec les couleurs de base (« red », « green , 

« blue ») avec une instruction comme « background-color:rgb(200,200,200); », où 

chaque valeur numérique est entre 0 et 255 inclusivement. 

CC BY-NC-SA

CSS 253 

3.3.6 Contenu en ligne ou en bloc 

Par défault, les éléments s’affichent en ligne, un à la suite de l’autre. On peut contrôler 

comment s’affiche un élément avec la propriété « display » qui peut prendre plusieurs 

valeurs dont celles-ci : 

– « display: none »: l’élément ne doit pas s’afficher. Par exemple, l’instruction « imgdisplay: 

none; » fait en sorte que les images ne s’affichent plus en HTML. Il est 

fréquent qu’avec du ECMAScript, on cache et affiche tour à tour des éléments pour 

donner l’impression que la page est dynamique. 

– « display: inline »: l’élément s’affiche à la suite du précédent comme s’il s’agissait 

d’un caractère. 

– « display: block »: l’élément s’affiche dans un bloc distinct, comme un nouveau 

paragraphe, par exemple. 

– « display: list-item »: l’élément s’affiche comme un élément d’une liste. 

Voici un exemple : 

p { display: block } 

strong { display: inline } 

li { display: list-item } 

img { display: none } 

On peut aussi définir la propriété « float » d’un élément qui lui permet de sortir du flot 

normal des éléments et de se placer à gauche ou à droite. Par exemple, une image en 

XHTML s’affiche normalement comme un bloc. On peut forcer l’image à s’intégrer 

au paragraphe suivant avec l’instruction « float: right » ou « float: left ». On peut aussi 

utiliser la propriété « float » pour créer plusieurs colonnes de texte comme dans un journal. 

Je vous invite à faire différentes expériences pour mieux comprendre l’utilisation 

de cette instruction. 

3.3.7 Centrer un élément 

Bien qu’on puisse changer la justification du texte avec une instruction comme « textalign: 

center », centrer un élément requiert plutôt une manipulation des marges avec la 

valeur spéciale « auto », comme dans cet exemple : 

p { width: 5cm; 

margin-left: auto; 

margin-right: auto;} 

Il aurait été sans doute préférable d’avoir une instruction dédiée pour centrer les éléments 

comme il s’agit d’une opération courante. 

CC BY-NC-SA


3.3.8 Les commentaires 

Tout comme en Java, on peut ajouter des commentaires à un fichier CSS qui sont systématiquement 

ignorés par la machine. Un bloc de commentaire débute par « /* » et se 

termine par « */ ». 

/* mon fichier css */ 

montant { 

color: red; /* la couleur rouge */ 

} 

3.3.9 Sélectionner le premier caractère ou la première ligne 

On peut sélectionner la première ligne d’un élément s’affichant en mode « block » et 

le premier caractère de tout élément avec les sélecteurs « :first-line » et :« :first-letter » 

respectivement. Voici un exemple : 

p:first-line {text-transform: uppercase} 

p:first-letter {font-size: 200%;float: left;} 

3.3.10 Ajouter du contenu avant et après un élément 

Avec CSS, on peut demander qu’une certaine chaîne de caractères apparaisse avant 

ou après un élément. Par exemple, si on veut ajouter automatiquement des guillemets 

avant et après un élément, on peut procéder comme ceci : 

blockquote:before {content:"«";} 

blockquote:after {content:"»";} 

Nous ne sommes pas limités au texte cependant. Il est possible, par exemple, d’ajouter 

automatiquement une image avant chaque élément comme ceci : 

p:before {content:url("monimage.png";} 

3.3.11 Qu’est-ce qu’un pseudo-élément 

Les instructions first-line, first-letter, before et after que nous venons de présenter sont 

les principaux exemples de pseudo-éléments. 

CC BY-NC-SA

CSS 255 

3.3.12 Sélecteurs d’intéraction 

Certains sélecteurs n’agissent qu’en réponse aux comportements de l’utilisateur. Par 

exemple, le sélecteur « p:hover » sélectionne les éléments « p » qui sont survolés par 

le curseur de la souris. Il existe plusieurs sélecteurs d’intéraction dont « :link » (lien 

non visité), « :visited » (lien visité), « active » (l’utilisateur utilise un élément), « :focus 

» (l’élément est sélectionné par l’utilisateur). On peut aussi combiner les sélecteurs 

comme dans cet exemple : « a:hover:focus ». On appelle aussi ces sélecteurs de pseudoclasses. 

3.3.13 Règles par défaut 

Dans le cas du HTML ou du XHTML, les navigateurs utilisent une liste de règles par 

défaut. Ces règles vont varier d’un navigateur à l’autre, mais voici un exemple de règles 

utilisées par Firefox : 

html, div { 


} 

body { 


margin: 8px; 

} 

p, dl, multicol { 


margin: 1em 0; 

} 

blockquote { 


margin: 1em 40px; 

} 

h1 { 


font-size: 2em; 

font-weight: bold; 

margin: .67em 0; 

} 

h2 { 


font-size: 1.5em; 

CC BY-NC-SA


} 


margin: .83em 0; 

pre { 


white-space: pre; 


} 

b, strong { 

font-weight: bolder; 

} 

i, cite, em, var, dfn { 


} 

u, ins { 

text-decoration: underline; 

} 

s, strike, del { 

text-decoration: line-through; 

} 

big { 

font-size: larger; 

} 

small { 

font-size: smaller; 

} 

sub { 

vertical-align: sub; 


line-height: normal; 

} 

sup { 

vertical-align: super; 


line-height: normal; 

CC BY-NC-SA

CSS 257 

} 

ul, menu, dir { 


list-style-type: disc; 


} 

ol { 


list-style-type: decimal; 


} 

li { 

display: list-item; 

} 

area, base, basefont, head, meta, script, style, title, 

noembed, param { 

display: none; 

} 

3.3.14 L’astérisque 

L’astérisque nous permet d’appliquer une règle à tous les éléments, comme dans cet 

exemple : « * color:red; ». 

3.3.15 Sélection sur la base des attributs 

Avec les CSS, en utilisant les crochets, nous pouvons sélectionner tous les éléments 

ayant un attribut donné. Par exemple, l’instruction « *[monattribut] color:red; » mettra 

en rouge tous les éléments ayant un attribut portant le nom « monattribut ». Nous 

pouvons aussi, bien sûr, limiter la sélection à des éléments portant un nom donné 

comme dans cet exemple : « maman[monattribut] color:red; » où les éléments « maman 

» ayant un attribut « monattribut » seront en rouge. Finalement, nous pouvons de 

plus limiter la sélection à des attributs ayant une certaine valeur, comme dans « maman[monattribut="papa"] 

color:red; ». 

Il arrive fréquemment qu’une valeur d’attribut contiennent plusieurs mots, comme dans 

« ». Pour séléctionner tous les élément dont 

un attribut contiennent un mot particulier, on remplace « = » par « = » comme dans 

l’instruction « *[pays ="Canada"] color:red; » qui mettra en rouge tout élément dont 

l’attribut « pays » contient le mot « Canada ». Les mots doivent être séparés par 

CC BY-NC-SA


des espaces. Dans l’éventualité où les mots sont séparés par des tirets, comme dans 

« », on peut obtenir le même résultat avec « |= » 

comme dans « *[pays|="Canada"] color:red; ». 


Les espaces de noms ne sont pas supportés en CSS 1 ou CSS 2. Ainsi « monelement 

color:red; » met en rouge le contenu de tous les éléments monelement, peu importe leur 

espace de noms. Il est incorrect d’utiliser la syntaxe « xhtml:monelement color:red; ». 

3.3.17 Sélection de la langue 

On a vu qu’il est possible en XML de spécifier la langue dans laquelle est écrit un texte 

avec l’attribut « xml:lang. ». On pourrait penser que pour mettre le texte déclaré comme 

étant en anglais en rouge, il suffirait de l’instruction « *[lang="fr"] color:red; », mais 

que se passera-t-il si on a utilisé un code de région avec la langue comme « fr-CA » 

Une solution plus élégante consiste alors à utiliser la sélection sur la langue avec une 

instruction comme « :lang(en) color:red; ». Une alternative est d’utiliser « *[lang|="fr"] 


3.3.18 Sélection de plusieurs éléments 

Supposons maintenant que nous voulions afficher en rouge tous les éléments « facture » 

et « maison ». Nous pouvons le faire avec deux instructions : 

facture { color:red;} 

maison { color:red;} 

En pratique cependant, il est préférable d’utiliser la virgule pour grouper les éléments, 

comme ceci : 

facture, maison { color:red;} 

Les deux instructions et cette dernière forme sont exactement équivalentes. 

3.3.19 Sélection sur la base de la relation entre les éléments 

Supposons maintenant que nous ne voulions pas afficher tous les éléments « personne » 

en rouge, mais seulement les éléments « personne » contenus dans un élément « facture 

». Nous obtiendrons ce résultat en plaçant les deux noms d’élément côte-à-côte 

(séparé par un espace). Ainsi, l’instruction « facture personne color:red; » affichera 

CC BY-NC-SA

CSS 259 

en rouge tous les éléments « personne » contenus dans un élément « facture », comme 

dans l’exemple qui suit : 

 

 

 

 

Jean Rochond 

 

 

ou dans ce deuxième exemple... 

 

 

 

 

Jean Rochond 

 

 

Nous pourrions vouloir que seuls les éléments immédiatement contenus dans l’élément 

« facture », comme dans le premier exemple, soient en rouge, et non pas ceux qui 

sont contenus dans des éléments eux-mêmes dans un élément « facture » (deuxième 

exemple). Nous pouvons obtenir ce résultat avec l’instruction « facture > personne 


En somme, la règle « a b color:red; » s’applique à l’élément « b », si l’élément 

« b » est contenu dans un élément « a » comme dans « » ou 

« ». 

Par contre, la règle « a > b color:red; » s’applique à l’élément « b », si et seulement 

si l’élément « b » est immédiatement contenu dans un élément « a », comme dans 

« ». Elle ne s’applique toutefois pas si « b » est contenu dans un 

élément lui-même contenu dans « a », comme dans « ». 

Supposons maintenant, dans l’exemple suivant, que nous voulions indenter le premier 

paragraphe (élément « p ») suivant le titre (élément « titre ») : 

 

Mon histoire 

C’est triste. 

Oui, c’est triste. 

Ce résultat s’obtient avec l’instruction « titre + p text-indent: 0cm; ». La syntaxe « a 

+ b ... » s’applique à l’élément « b » quand les éléments « a » et « b » sont contenus 

CC BY-NC-SA


dans le même élément, et que « b » est immédiatement après « a ». Notez que la règle 

« a + b ... » s’applique à « b », mais ne s’applique pas à « a ». 

Supposons que nous désirions indenter le premier paragraphe (élément « p ») dans 

l’élément « section » : 

 

 

C’est triste. 

Oui, c’est triste. 

 

On peut obtenir ce résultat avec la sélecteur « section > p:firstchild ... » où « :firstchild 

» signifie que seuls les éléments « p » étant le premier élément au sein d’un autre 

élément sont sélectionnés. En fait, dans cet exemple particulier, on obtiendrait aussi le 

résultat voulu avec le sélecteur « p:firstchild ... ». 

Par ailleurs, nous pouvons combiner les espaces, les « + », les virgules et les « > » dans 

un même sélecteur. Par exemple, « a + b, c ... » s’applique aux éléments « c » et aux 

éléments « b » qui suivent immédiatement un élément « a ». 

3.3.20 Sélection d’élément par valeur ID 

Si vous avez des éléments ayant des attributs ayant une valeur de type « ID », on sait 

alors que leur valeur est un nom XML et qu’elle ne doit être utilisée qu’une seule 

fois. C’est le cas des attributs de la forme « id="xxx" » que l’on peut utiliser avec 

pratiquement tous les éléments XHTML. On peut sélectionner un élément basé sur la 

valeur d’un tel attribut en utilisant le symbole « # » : 

#xxx { 

color: red; 

} 

Dans ce cas, le contenu d’un élément comme une balise XHTML « test » s’affichera en rouge. On peut combiner les sélecteurs « # » avec 

les autres règles que nous avons traitées , par exemple, le code suivant ne mettra en 

rouge que les éléments « i » contenus dans un élément ayant un attribut de type « ID » 

avec pour valeur « xxx » : 

#xxx i{ 

color: red; 

} 

CC BY-NC-SA

CSS 261 

3.3.21 Mais que se passe-t-il en cas de conflit 

Plusieurs instructions peuvent s’appliquer en même temps: un texte peut être en rouge 

et souligné. Il peut arriver cependant que deux instructions CSS se contredisent. Par 

exemple, un texte ne peut être à la fois en rouge et en bleu. Dans ce cas, la sélection la 

plus spécifique l’emporte. Ainsi, dans l’exemple qui suit... 

* { 

color: black; 

} 

montant { 

color: red; 

} 

montant > montant { 

color: yellow; 

} 

les éléments « montant » seront en rouge, sauf s’ils sont immédiatement contenus dans 

un autre élément « montant », auquel cas ils seront en jaune. 

Par ailleurs, si deux sélections de même spécificité sont rencontrées, c’est la dernière 

qui l’emporte. Ainsi, dans l’exemple qui suit... 

montant { 

color: red; 

} 

montant { 

color: black; 

} 

les éléments « montant » seront en noir. 

On peut cependant forcer le navigateur à considérer une règle qui apparaît avant une 

autre comme ayant tout de même priorité (à spécificité égale). Il suffit d’utiliser la 

mention !important... 

montant { 

color: red !important; 

} 

montant { 

color: black; 

} 

CC BY-NC-SA


les éléments « montant » seront en rouge. Notez que la mention !important permet 

souvent d’ignorer la spécificité de la règle: les règles avec cette mention l’emportent 

toujours sur les autres. (Si une autre règle avec la mention !important a une plus grande 

spécificité, elle aura bien sûr priorité.) 

Les règles par défaut utilisées par votre navigateur dans le cas du HTML ou du XHTML 

sont lues en premier. De cette manières, toutes les règles qui vous stipulez dans vos 

propres fichiers CSS et à même le XML ou HTML ont priorité pour une même spécificité. 

On peut considérer que les règles avec la mention !important sont lues en dernier 

dans la mesure où ils l’emportent toujours sur les autres. 

Calculer la spécificité des règles n’est pas une mince affaire, mais c’est pourtant nécessaire 

dans certains cas difficiles. La spécificité se mesure avec une valeur à 4 chiffres 

(a,b,c,d). Lorsqu’on compare deux spécificités (a1,b1,c1,d1) et (a2,b2,c2,d2), on utilise 

l’ordre lexicographique pour déterminer lequel est supérieur. Ainsi, si a1 est plus 

grand que a2, alors (a1,b1,c1,d1) a une plus grande spécificité que (a2,b2,c2,d2), si a1 

est égal à a2, alors on compare b1 et b2, et ainsi de suite. 

– La première valeur (a) vaut 1 si et seulement si la règle apparaît dans le fichier 

XML, HTML ou XHTML dans un attribut style. Par exemple, si on a un élément 

paragraphe en HTML de cette forme , alors la règle color:red 

aura une très grande spécificité. 

– La seconde valeur (b) est le nombre de sélections sur la valeur ID utilisée par la 

règle. Ainsi, la règle #x color:red pourra avoir une spécificité de 0,1,0,0. En pratique, 

la sélection par valeur ID l’emporte souvent sur les autres règles. 

– La troisième valeur (c) est le nombre de valeurs d’attributs utilisées par la règle (excluant 

l’attribut ID). Ainsi, la règle *[monattribut] color:red; pourrait avoir comme 

spécificité 0,0,1,0. Les pseudo-classes comptent comme des attributs. 

– La quatrième valeur (c) est le nombre d’éléments utilisés par la règle. Ainsi, la règle 

p[monattribut] color:red; pourrait avoir comme spécificité 0,0,1,1. 

Pour mieux comprendre, prenons un exemple concret... 

z[x] > a[i] {color: blue;} 

z z[x] a {text-decoration: underline;} 

z > z a , z z z + a { color: red ;} 

Il est plus facile de comptabiliser la spécificité si on écrit les règles individuellement 

(sans la virgule). Voyez si vous êtes capable de voir pourquoi les différentes règles ont 

les spécificités annoncées dans les commentaires... 

/* spécificité: 0,0,2,2 */ 

z[x] > a[i] {color: blue;} 


z > z a { color: red ; } 

CC BY-NC-SA

CSS 263 


z z z + a { color: red; } 


z z[x] a {text-decoration: underline;} 

Prenons maintenant un fichier XML auquel on applique les instructions CSS précédente. 

L’élément a dans le fichier suivant est sélectionné par les 4 règles du fichier 

CSS. Comment sera affiché le texte dans votre navigateur 

 

 

 

 

mon texte 

 

 

Le texte apparaîtra en bleu et sera souligné. Si on ajoute une instruction avec la mention 

!important comme « * color: black !important; » alors on peut faire en sorte que le 

texte soit noir. 

3.3.22 Le modèle de boîte CSS 

En CSS, on peut spécifier la hauteur et la largeur d’un objet à l’aide des instructions 

« width » et « height ». Par exemple, pour indiquer qu’un paragraphe devrait n’avoir 

qu’une largeur de 20 pixels, on utilise un sélecteur comme celui-ci : 

p{ 

width: 20px; 

} 

Le CSS supporte plusieurs unités de mesure outre les pixels dont les pouces (in), les 

centimètres (cm), pourcentage (%), etc. 

On peut ensuite définir une marge (margin en anglais) autour de tout objet. La marge 

est une région où rien ne peut apparaître, incluant un autre objet. Mais la marge ne fait 

pas partie de l’objet lui-même. Ainsi, si un objet fait 10 pixels de hauteur et de largeur, 

et que vous définissez une marge de 10 pixels tout autour de l’objet, un espace d’une 

superficie de 900 pixels sera occupée sur l’écran. Voici un exemple de marge : 

p{ 

margin-top:10px; 

margin-bottom:10px; 

margin-right:10px; 

margin-left:10px; 

CC BY-NC-SA


} 

Outre la marge, on peut aussi définir une région d’espacement (padding en anglais). 

Contrairement à la marge, la région d’espacement fait partie de l’objet dans la mesure 

où, si vous définissez une couleur de fond pour l’objet, la région d’espacement sera 

colorée, car elle fait partie de l’objet. Tout comme la marge, rien n’occupe cette région 

et elle n’est pas comptabilisée dans la hauteur et la largeur de l’objet. 

p{ 

padding-top:10px; 

padding-bottom:10px; 

padding-right:10px; 

padding-left:10px; 

} 

On peut définir une bordure (border en anglais) afin de tracer un ligne tout autour de 

l’objet. La bordure se place entre la région d’espacement et la marge. La bordure peut 

prendre différente épaisseurs (telles que thin, medium, et thick) et aussi une couleur. 

p{ 

border-color: black; 

border-width: medium; 

} 

Voici un diagramme qui résume les différentes définitions : 

bordure (border) 

margin−left 

padding−left 

margin−top 

padding−top 

Contenu ici 

espacement (padding): espace laissé 

vacant 

padding−right 

rmargin−right 

hauteur de l’objet (height) 

marge (margin): rien ne peut apparaître ici 

margin:bottom 

largeur de l’objet (width) 

CC BY-NC-SA

CSS 265 

3.3.23 Quand le contenu excède le contenant 

Il arrive qu’une image ou qu’un texte excède la taille de l’élément dans lequel il a été 

placé. Par défaut, ce texte ou cet image s’affichera au-delà du cadre de sa boîte (« overflow:visible 

»). L’instruction « overflow:hidden » permet de faire disparaître la partie 

d’un texte ou d’une image qui excède la boîte, alors que l’instruction « overflow:scroll » 

va faire apparaître des barres de défilement pour permettre à l’utilisateur d’avoir accès 

à tout le contenu sans pour autant avoir un dépassement.. 

3.3.24 Encodage des caractères 

Il peut être utile de spécifier l’encodage des caractères utilisé pour créer le document 

CSS. Il suffit d’inclure une instruction « @charset » au tout début du document. Voici 

deux exemples : 

@charset "UTF-8"; 

@charset "ISO-8859-1"; 

3.3.25 Différentes règles pour différents média 

Il arrive qu’on veuille qu’une page s’affiche différemment selon qu’on utilise un écran, 

qu’on l’imprime sur papier ou qu’on utilise un téléphone cellulaire. L’instruction 

« @media » permet de préciser quel médium est concerné par la règle. Plusieurs média 

sont reconnus dont « handheld » (appareil portable comme un téléphone cellulaire), 

« screen » (à l’écran), « tv » (sur un téléviseur), « print » (sur papier), etc. Lorsque 

l’instruction « @media » n’est pas précisée, la règle s’applique tout le temps. Voici un 

exemple : 

@media print, handheld { 

img { display: none } 

h1 {color: black } 

} 

@media screen, tv { 

h1 {color: blue } 

} 

3.3.26 Inclure d’autres fichiers CSS 

Il arrive parfois qu’on veuille adopter une approche modulaire et créer plusieurs petits 

fichiers CSS. L’instruction « @import » apparaissant avant le début des règles, mais 

après une éventuelle instruction « @charset » permet d’inclure un ou plusieurs fichiers 

CSS. On peut aussi spécifier le type de médium concerné. 

CC BY-NC-SA


@import "mineure.css"; 

@import "print-mineure.css" print; 

3.3.27 Indentation de la première ligne d’un paragraphe 

On peut indenter la première ligne d’un paragraphe avec l’instruction « text-indent ». 

Par exemple, pour indenter la première ligne de tous les paragraphes par 1 cm, on peut 

utiliser l’instruction « text-indent: 1cm ». 

3.3.28 Modifier la casse du texte 

L’instruction « text-transform » permet de modifier la casse du texte ce qui est particulièrement 

utile avec les titres. Par exemple, « text-transform: capitalize » modifie le 

texte de manière à ce que le premier caractère de chaque mot soit en majuscule. Les 

instructions « text-transform: uppercase » et « text-transform: lowercase » permettent 

de passer à une casse uniforme (majuscule ou minuscule). Finalement, l’instruction 

« text-transform: capitalize » met le premier caractère de chaque mot en majuscule. 

3.3.29 Autres variantes des polices 

Il est possible de modifier de diverses façons les polices : « font-style:italic », « fontstyle:oblique 

» « font-family: sans-serif », « font-family: serif », « font-weight: bold », 

« font-weight: bolder », « font-weight: lighter ». On peut modifier la taille des caractères 

: « font-size: large », « font-size: small ». On peut ajouter des lignes sous, sur ou 

au dessus le texte, ou faire clignoter le texte : « text-decoration: underline », « textdecoration: 

overline », « text-decoration: line-through », « text-decoration: blink ». 

Vous pouvez aussi spécifier l’apparence que prendra le curseur avec l’attribut « cursor 

» qui prend la valeur « text » par défaut, et la valeur « pointer » pour les hyperliens. 

3.3.30 Ajouter des compteurs 

On peut définir des compteurs pour, par exemple, numéroter des chapitres ou paragraphes. 

Ce premier exemple numérote les paragraphes (éléments « p ») contenus entre 

chaque élément « h1 » avec des nombres romains : 

p {counter-increment: par-num} 

h1 {counter-reset: par-num} 

p:before {content: counter(par-num, upper-roman) ". "} 

Ce second exemple numérote les éléments « h1 » avec des nombres arabes : 

CC BY-NC-SA

CSS 267 

h1 {counter-increment: h1-num} 

h1:before {content: counter(h1-num, decimal) ". "} 

Ce troisième exemple « numérote » les éléments « h1 » et « h2 » avec des lettres 

(a,b,c,...) : 

h1 {counter-reset: h2counter; counter-increment: h1counter} 

h2 {counter-increment: h1counter} 

h1:before {content: counter(h1counter, lower-latin) ". "} 

h2:before { 

content: counter(h1counter, lower-latin) "." 

counter(h2counter, lower-latin) ". " } 

3.3.31 Traitement des retours de chariot 

Par défaut, le contenu textuel d’un élément est affiché sans tenir compte des retours 

de chariot présents dans le fichier XML, mais en insérant plutôt des retours de chariot 

au besoin. Avec l’instruction « white-space : pre », on force le maintient des retours 

de chariot là où ils sont, ce qui est très utile pour présenter du code informatique. 

L’instruction « white-space : nowrap » élimine toute utilisation des retours de chariot, 

alors que l’instruction« white-space : normal » correspond au comportement pas défaut. 

3.3.32 Des nouveautés en CSS 3 

La prochaine version du CSS, CSS 3, apporte de nombreuses améliorations. En particulier, 

elle ajoute plusieurs sélecteurs. Voici un tableau qui résume certains des sélecteurs 

les plus utilisés ainsi que le niveau CSS correspondant. 

Sélecteur Signification Niveau CSS 

* tout élément 2 

E un élément de nom E 1 

E[foo] 

un élément E ayant un attribut 

2 

foo 

E[foo="bar"] 


2 

foo dont la valeur 

est « bar » 

E[foo ="bar"] 


2 


contient le mot « bar » séparé 

par des espaces 

E[fooˆ="bar"] 


foo débute par le 

texte « bar » 

3 

CC BY-NC-SA


Sélecteur Signification Niveau CSS 

E[foo$="bar"] 


3 

foo se termine par 

le texte « bar » 

E[foo*="bar"] 


3 


contient le texte « bar » 

E[foo|="bar"] 


2 


contient le mot « bar » séparé 

par des tirets 

E F un élément F contenu 1 

dans un élément E 

E > F 

un élément F contenu directement 

2 

dans un élé- 

ment E 

E + F un élément F précédé 2 

immédiatement par un 

élément-voisin E 

E F 

un élément F précédé par 

un élément-voisin E 

3 

Avec CSS 3, il devient donc possible, par exemple, de sélectionner tous les hyperliens 

ayant une adresse (attribut « href ») débutant par « http » avec le sélecteur 

« a[hrefˆ="http"] », ce qui pourrait être utilisé pour indiquer visuellement les liens 

externes. 

3.3.33 Optimisation des fichiers CSS 

Il y a plusieurs façons d’écrire un même ensemble d’instructions. Par exemple, ce fichier 

CSS est trop long et difficile à comprendre : 

montant { 

color: red; 


background:white; 

font-style: normal; 

text-align: center; 

} 

nom { 

color: white; 



text-align: left; 

} 

CC BY-NC-SA

CSS 269 

texte { 

color: black; 





} 

On peut le réécrire dans un format plus concis et plus clair : 

montant { 

color: red; 



} 

nom { 

color: white; 


} 

texte { 

color: black; 


} 

montant, nom, texte { 

background: white; 


} 

Il existe de nombreux outils pour optimiser les fichiers CSS dont CSSTidy qui est 

disponible en ligne. 

3.3.34 En terminant 

La syntaxe CSS est beaucoup plus riche que ce que nous venons de voir. Pour 

plus d’information, nous vous invitons à lire le document de référence http:// 

www.yoyodesign.org/doc/w3c/css2/ ou les articles du site mozilla.org (http://developer.mozilla.org/en/docs/CSS). 

. 


– David Sawyer McFarland, CSS: The Missing Manual, O’Reilly Media, 2006, 476 

pages. 

CC BY-NC-SA


– Charles Wyke-Smith, CSS 2, guide du designer, Pearson Education France, 2005, 

268 pages. 


1. Quelle affirmation décrit le mieux un document CSS Choisissez la bonne réponse 


(a) Un document CSS doit être un document XML valable. 

(b) Un document CSS doit spécifier le document XML auquel il se rattache. 

(c) Un document CSS précise une façon de présenter certains éléments XML. 

2. Supposons que j’applique un fichier CSS vide au document XML suivant... 

 

Marc Popowich 

1010.24 


 

Qu’est-ce que le navigateur devrait afficher 


(a) Rien. 

(b) Marc Popowich 1010.24 Achat d’ordinateur 

(c) Marc Popowich 1010.24 Achat d’ordinateur 

(d) Marc Popowich 1010.24 Achat d’ordinateur 

(e) Marc Popowich 

3. Supposons que j’applique le fichier CSS suivant... 

* { 


} 

montant { 

text-decoration: underline; 

} 

au document XML suivant... 

 

Marc Popowich 

1010.24 


 

CC BY-NC-SA

CSS 271 

Qu’est-ce que le navigateur devrait afficher 


(a) Rien. 

(b) Marc Popowich 1010.24 Achat d’ordinateur 

(c) Marc Popowich 1010.24 Achat d’ordinateur 

(d) Marc Popowich 1010.24 Achat d’ordinateur 

(e) Marc Popowich 

4. Étant donné le document XML suivant : 

 

 

 

Marc 

Antoine 

Popowich 

 

 

Quels documents CSS mettront « Marc » et « Antoine » en rouge, et rien d’autre. 


(a) personne prenom { 

color: red; 

} 

(b) prenom personne { 

color: red; 

} 

(c) facture prenom { 

color: red; 

} 

(d) facture > prenom { 

color: red; 

} 

(e) personne > prenom { 

color: red; 

} 

CC BY-NC-SA


(f) prenom + prenom { 

color: red; 

} 

5. Étant donné le document XML suivant : 

 

 

 

Marc 

Antoine 

Popowich 

 

 

Quels documents CSS permettent d’afficher uniquement « Marc Popowich » 


(a) prenom { 


} 

(b) prenom[special] { 


} 

(c) prenom[num] { 


} 

(d) *[special] { 


} 

(e) *[num="2"] { 


} 

6. Quelle instruction CSS sélectionnera les éléments « facture » et « montant » 


(a) facture | montant 

(b) facture > montant 

(c) facture + montant 

CC BY-NC-SA

CSS 273 

(d) facture, montant 

7. Quelle instruction CSS ne sélectionnera que les éléments nommés « racine » 


(a) racine 

(b) * racine 

(c) #racine 

(d) racine () 

8. Quelle instruction CSS ne sélectionnera que les éléments « input » avec l’attribut 

« type="text" » Choisissez la bonne réponse parmi les choix suivants. 

(a) input[type="text"] 

(b) input[.text] 

(c) input.text 

(d) input[type:"text"] 

9. Quelle instruction CSS ne sélectionnera que les éléments « a », « b » et « c » 


(a) a | b | c 

(b) a, b, c 

(c) a b c 

(d) a + b + c 

10. Quelle instruction CSS sélectionnera les éléments « p » qui sont contenus dans 

un élément « li » Choisissez la bonne réponse parmi les choix suivants. 

(a) li < p 

(b) li p 

(c) li.p 

11. Quelle instruction CSS sélectionnera les éléments « p » directement contenus 

dans un élément « li » (« p » est un enfant immédiat de « li ») Choisissez la 


(a) li p 

(b) li > p 

(c) li < p 

(d) li.p 

CC BY-NC-SA



1. (a) Non. En fait, un document CSS n’est pas du XML. 

(b) Non. En général, un document CSS peut être utilisé par plusieurs documents 

XML. 

(c) (Bonne réponse) Oui, c’est une façon de décrire ce qu’est un document 

CSS. 

2. (a) Non. Par défaut, un texte devrait s’afficher. 

(b) (Bonne réponse) Exact. La présentation par défaut affiche le texte en ligne, 

normalement. 

(c) Non. 

(d) Non, il n’y a aucune raison pour que le texte soit en italique. 

(e) Non. 

3. (a) Non. 

(b) Non. 

(c) (Bonne réponse) Exact. Tous les éléments sont en italique et l’élément 

« montant » est souligné. 

(d) Non, l’élément montant est en italique, mais il n’est pas souligné. 

(e) Non. 

4. (a) (Bonne réponse) Correct. Ce code met en rouge tous les éléments « prenom 

» contenus dans des éléments « personne ». 

(b) Non. Ce code ne met en rouge que les éléments « personne » qui suivent 

des éléments « prenom », ce qui ne se produit pas dans le document XML 

fourni. 

(c) (Bonne réponse) Correct. Ce code met en rouge tous les éléments « prenom 

» contenus dans des éléments « facture », même si c’est au deuxième 

niveau, par l’élément « personne ». 

(d) Non. Ce code ne met en rouge que les éléments « prenom » contenus au 

premier niveau, soit dans l’élément « facture », mais pas dans un autre 

élément. 

(e) (Bonne réponse) Oui. Ce code ne met en rouge que les éléments « prenom » 

contenus au premier niveau, soit dans l’élément « personne », mais pas dans 

un autre élément. 

(f) Non. Dans ce cas, seul le second élément « prenom » rencontré sera en 

rouge. En effet, le symbole « + » fonctionne de la manière suivante : si on 

a « ab », alors la clause CSS « A+B propriete: valeur » 

ne s’applique qu’à l’élément « B ». 

5. (a) Non. Si on utilise ce fichier CSS, seulement le nom « Popowich » s’affichera. 

(b) (Bonne réponse) Oui. Seuls les éléments « prenom » avec un attribut ayant 

pour nom « special » seront cachés. 

CC BY-NC-SA

CSS 275 

(c) Non. Si on utilise ce fichier CSS, on n’affichera que le nom Popowich 

(d) (Bonne réponse) Oui. Seuls les éléments avec un attribut ayant pour nom 

« special » seront cachés. 

(e) (Bonne réponse) Oui. Seuls les éléments avec l’attribut « num="2" » seront 

cachés. 

6. (a) Le symbole « | » n’est pas permis. 

(b) Cette instruction ne sélectionne que les éléments « montant » qui sont immédiatement 

contenus dans un élément « facture ». 

(c) Cette instruction ne sélectionne que les éléments « montant » qui suivent 

immédiatement un élément « facture ». 

(d) (Bonne réponse) Effectivement. Cela est équivalent à deux instructions : 

l’une avec « facture » et l’autre avec « montant ». 

7. (a) (Bonne réponse) C’est juste. Seuls les éléments « racine » sont sélectionnés. 

(b) Cette syntaxe sélectionne tous les éléments « racine », sauf s’ils sont un 

élément-racine. 

(c) Dans le contexte du XHTML, cette instruction sélectionne tous les éléments 

qui ont un attribut « id="racine" ». 

(d) Cette instruction n’est pas valable en CSS. 


(b) Cette instruction n’est pas valable : elle sélectionnerait les éléments « input 

» ayant un attribut nommé « .text », mais ce nom n’est pas permis pour 

les attributs. 

(c) Dans le contexte du XHTML, cette instruction sélectionnera les éléments 

« input » ayant un attribut « class="text" ». 

(d) Cette syntaxe n’est pas valable en CSS. 

9. (a) Le symbole « | » n’est pas permis. 

(b) (Bonne réponse) Oui. En effet, on peut combiner plus de deux éléments 

avec des virgules. 

(c) Bien qu’il s’agisse de CSS valable, cette instruction ne sélectionnerait que 

les éléments « c », à certaines conditions (« c » contenu dans « b », luimême 

contenu dans « a »). 

(d) Bien qu’il s’agisse de CSS valable, cette instruction ne sélectionnerait que 

les éléments « c », à certaines conditions (« c » qui suit « b » qui suit « a »). 

10. (a) Le symbole « < » n’est pas permis. 


(c) Dans le contexte du XHTML, cette instruction sélectionnerait les éléments 

« li » ayant l’attribut « class="p" ». 

11. (a) Non. Elle ne requiert pas que « p » soit immédiatement dans « li ». 

CC BY-NC-SA



(c) Le symbole « < » n’est pas permis. 

(d) Dans le contexte du XHTML, cette instruction sélectionnerait les éléments 

« li » ayant l’attribut « class="p" ». 




Il contribue à l’objectif suivant : 

– Utiliser des transformations XSLT et des instructions CSS. 

Le travail comprend cinq exercices : le premier vaut 3 points, le deuxième vaut 2 points, 

le troisième vaut 2 points, le quatrième vaut 2 points, et le cinquième vaut 1 point. 


Faites les exercices et répondez aux questions en utilisant Firefox comme moteur XSLT 

et comme navigateur; les exercices ont été conçus en fonction de ce navigateur. Certains 

étudiants trouvent pratique d’utiliser l’outil de traitement en ligne disponible sur 

le blogue du cours (http://www.daniel-lemire.com/blogue/xsltprocessor.html). En effectuant 

les exercices, n’utilisez que des fonctions disponibles dans Firefox. De plus, 

n’utilisez pas les éléments « xsl:key » ou la fonction XPath « key » dans vos solutions. 

Une fois votre travail terminé, transmettez à votre personne tutrice, par courriel, un 

document (Word 97/2000/XP, ODF, PDF, RTF ou en format texte) en fichier attaché. 




« Travail noté 4 » et « INF 6450 ». Il s’agit d’un travail personnel et vous ne devez 

pas partager vos solutions. 

Bon travail! 

3.4.3 Exercice 1 

Étant donné le document XML suivant, rédigez le contenu du document CSS 

« test.css », de telle sorte que les mots « Rouge » s’affichent en rouge, les mots « Noir » 

s’affichent en noir, les mots « majuscule » s’affichent en majuscule et ainsi de suite. 

CC BY-NC-SA


Votre document CSS doit contenir au plus 5 instructions CSS de la forme « quelque 

chose autre chose ». 

Indice : Vous pouvez utiliser « color:red », « color:olive », « color:black », « color:blue 

», et ainsi de suite pour fixer la couleur du texte. 

 

 

 

Rouge 

Olive 

Bleu 

Noir 

Olive 

Bleu 

Rouge 

Noir 

 

Rouge 

Noir 

majuscule 

 


Supposons que toutes les notes des étudiants, dans différents cours, se trouvent dans le 

document XML suivant : 

 

 

 

Réjean Tremblay 

 

 

 

Martin Lambert 

 

 

 

Luc Alain 

 

 

 

Olive Saint-Amant 

 

CC BY-NC-SA


 

 

À partir de ce document XML, fournissez le document XSLT « class.xsl » qui calcule 

les moyennes des étudiants, d’après les éléments « cours » associés aux éléments « étudiant 

», et qui trie les étudiants par ordre alphabétique de leur nom de famille. Votre 

document XSLT doit fonctionner même si on change le nom des étudiants, l’ordre des 

éléments et le nom des cours. En conséquence, le nom des étudiants ou le nom des 

cours ne peuvent apparaître dans votre document XSLT. En outre, vous ne devez pas 

utiliser les crochets « [ ] » dans votre solution. 

Indices 

1. Le tableau ci-dessous devrait vous permettre de vérifier votre réponse. 

Étudiant 

Moyenne 

Luc Alain 69.0 

Martin Lambert 73.3 

Olive Saint-Amant 95.0 

Réjean Tremblay 77.7 

2. Vous pouvez trier les étudiants selon leur nom de famille, en remplaçant 

« » par : 

 

 

 

3. Vous pouvez formater les nombres à virgule flottante comme dans le tableau, 

en utilisant des appels de fonction XSLT tels que « format-number(10.1324, 

’##.0’) ». 


Utilisez le même document XML qu’à l’exercice précédent. Cette fois-ci, comptez 

le nombre d’étudiants dans chaque cours et calculez la moyenne par cours. Encore 

une fois, les noms des cours ou des étudiants ne doivent pas apparaître dans votre 

document XSLT. 

Le tableau qui suit présente le résultat. 

Sigle Nombre d’étudiants Moyenne du cours 

INF8430 3 85.0 




CC BY-NC-SA


Bien que cet exercice soit très similaire au précédent et que la solution soit de même 

longueur, vous le trouverez probablement plus difficile. 

Note. Si vous aviez le droit d’utiliser XSLT 2.0, la nouvelle instruction « xsl:for-eachgroup 

» rendrait ce problème plus facile. Mais rappelez-vous que vous devez vous 

limiter à XSLT 1.0. 


Supposons que vous ayiez des documents contenant exclusivement une déclaration 

XML, des éléments et des attributs. Il n’y a pas d’espace de noms. Vous souhaitez 

filtrer les documents XML de telle manière que seuls les éléments dont le nom contient 

la lettre a sont inclus. Naturellement, les éléments, peu importe leur nom, qui ne sont 

pas contenus dans un élément dont le nom contient la lettre a doivent être omis. Le 

document XML devra contenir une instruction xml-stylesheet, mais elle ne doit pas 

être reproduite dans le document sortant. 

Par exemple, si on prend cet exemple: 

 

 

 

Testz 

z 

 

On souhaite que le document sortant soit celui-ci: 

 

 

z 

 

Vous devez proposer deux documents XSLT permettant de réaliser ce filtrage. Le premier 

document ne devra pas contenir d’élément « xsl:element », alors que le second ne 

contiendra pas d’élément « xsl:copy ». 


Considérez le fichier XML de la question 2 comprenant les notes des étudiants. Écrivez 

une requête XQuery qui calcule la moyenne des notes de chaque cours et la présente 

sous cette forme : 

 

85 

76.66666666666667 

CC BY-NC-SA


81.5 

39 

 

Vous pouvez utiliser la fonction avg qui calcule la moyenne. 

CC BY-NC-SA

Module 4 : Traitement du XML 

en Java 

4.1 Aperçu 


Dans le premier module, nous avons appris ce qu’était le XML du point de vue technique. 

Dans le module 2, nous avons vu le rôle que jouait le XML dans l’organisation 

et sur le web. Le module 3 portait sur les technologies propres aux XML pour la présentation 

et la transformation des documents. Le module 4 porte sur le traitement du 

XML à partir d’un langage orienté objet, particulièrement Java. 

En pratique, le XML n’opère pas en vase clos. Les entreprises ont déjà des bases de 

données relationnelles, des logiciels spécialisés, des serveurs et ainsi de suite. Même 

si nous le pouvions, il serait impossible d’utiliser uniquement du XML : il faut nécessairement 

utiliser d’autres technologies, telle la programmation orientée objet, Java par 

exemple. 

On pourrait écrire ses propres fonctions pour traiter le XML, mais on utilise plus souvent 

une API. Rappelons qu’une API (Application and Programming Interface en anglais 

ou Interface pour la programmation d’applications en français) est un ensemble 

de fonctions et d’objets facilitant la programmation d’applications. 

Pour le traitement du XML en Java, il y a deux aspects importants à prendre en compte. 

Il faut d’abord bien connaître l’approche DOM (Document Object Model) qui sert de 

référence à toutes les API orientées objets destinées au traitement du XML. En outre, il 

faut acquérir suffisamment d’expérience dans ce domaine pour pouvoir juger convenablement 

de la quantité de travail nécessaire au développement d’une application Java 

utilisant le XML. 

Les objectifs spécifiques du module sont : 


281


– Appliquer la méthodologie orientée objet pour la consommation, la fusion et le filtrage 


Une activité nécessitant de la programmation, le travail noté 5, nous permettra d’évaluer 

votre atteinte de cet objectif. 


Avant de commencer l’étude du module 4, vous devez avoir terminé les modules 1 et 3. 

Il n’est toutefois pas nécessaire de terminer ce module avant de passer au module 5. 

Nous vous invitons à étudier ce module dans l’ordre suivant : 

– Modèles de programmation 

– Rappel sur la programmation Java 

– Tutoriel sur DOM et AJAX 

– DOM (autoévaluation) 

Lisez les textes et vérifiez vos connaissances en répondant aux questionnaires d’autoévaluation, 

s’il y a lieu; réalisez ensuite le travail noté 5 qui prend la forme d’une activité 

de programmation. 

Important.- Avant de réaliser le travail noté 5, vous devriez avoir répondu aux deux 

questionnaires d’autoévaluation, en maîtriser le contenu et avoir terminé l’étude du 

module 3. 

4.2 Modèles de programmation 


Connaître des méthodologies de traitement du XML, dont l’approche DOM. 



sur les modèles de programmation en XML et présente les méthodologies communes 

pour la programmation en vue de traiter du XML. Il conclut avec quelques problèmes 

communs. 

Il y a plusieurs façons de traiter du XML. Chaque méthode a ses avantages et ses inconvénients. 

Bien que ce module s’intéresse surtout à l’approche DOM, il est important 

de connaître l’ensemble des méthodologies possibles et d’avoir une idée des forces et 

faiblesses relatives de chacune. 

CC BY-NC-SA

Modèles de programmation 283 

4.2.3 Traitement du XML comme du texte 

Un fichier XML est d’abord un fichier texte. Comme certains langages, tel Java, savent 

bien traiter les fichiers en format texte, ils peuvent directement traiter le XML. En fait, 

du moment où nous utilisons un éditeur de texte pour écrire du XML, c’est exactement 

ce que nous faisons : nous utilisons, comme outil XML, un programme prévu pour 

traiter du texte. 

Par exemple, nous pouvons produire du XML à partir d’un programme Java avec des 

instructions comme celles qui suivent : 

int montant = 10; 

String nom= "Gérard Beauford"; 

System.out.println(" "+montant 

+""+nom+""); 

Cependant, comment savoir si le XML produit est bien formé Dans l’exemple précédent, 

le document XML affiché à l’écran avec l’instruction « System.out.println » ne 

sera pas du XML bien formé. Pourquoi Il y a un accent dans le nom et la plupart des 

environnement de commande n’utilisent pas la norme UTF-8. En principe, il est possible 

d’écrire un programme Java qui génère du XML bien formé la plupart du temps; 

mais, une fois de temps en temps, il se produira une erreur dans le XML. Cette erreur 

pourrait toutefois être suffisamment sérieuse et entraîner un bogue important : Mozilla 

Firefox refusera d’afficher du XML qui n’est pas bien formé. Pour cette raison, il est 

préférable, quand cela en vaut la peine, d’utiliser des librairies ou outils dédiés au XML 

pour une meilleure productivité. 

De la même façon, lire du XML sans avoir recours à des librairies peut être difficile; 

par exemple, supposons qu’il faille écrire un programme Java sans utiliser des librairies 

capables d’extraire le nom et le montant du fichier XML suivant : 

 

432 

Gérard Beauford 

Un tel programme peut être relativement difficile à écrire. Nous pouvons toutefois bien 

y arriver avec les expressions régulières (voir le paquetage « java.util.regex » en Java), 

mais dans le cas de fichiers XML plus complexes, le programme risque de devenir long 

et fastidieux. 

Illustrons comment les choses peuvent se corser davantage en étudiant l’exemple suivant 

: 

 

 

CC BY-NC-SA


 

 

]> 

432Gérard Beauford 

Supposons maintenant que vous deviez écrire un programme Java pour déterminer la 

valeur de l’attribut « surnom » de l’élément « nom » de ce document XML. Nous 

constatons qu’il faut traiter non seulement le XML, mais aussi la DTD. Et nous savons 

que les DTD sont le plus souvent externes, ce qui rend le problème encore plus difficile. 

Supporter l’ensemble des normes XML devient rapidement très fastidieux : pensons 

aux entités, déclarations XML, et ainsi de suite. 

Donc, le traitement du XML en tant que texte est une méthode qui, sans être inappropriée, 

a ses limites. 

4.2.4 Traitement événementiel 

Le traitement événementiel est une approche très simple pour traiter le XML, mais 

qui peut être difficile pour le programmeur. En fait, une API, souvent l’API SAX, 

est utilisée pour lire le XML en séquence. Une alternative à SAX est XNI (Xerces 

Native Interface). Chaque fois qu’une nouvelle balise ou tout autre élément significatif 

(instruction XML, contenu XML, etc.) est rencontré, un « événement » est généré. 

C’est le même type de traitement qui est utilisé pour gérer l’interface graphique avec 

boutons, fenêtres, etc.; dans ce type de traitement toutefois, l’événement « presse le 

bouton » est plutôt du type « nouvel élément rencontré ». 

Par exemple, avec le document XML qui suit... 

432Maman 

nous aurons les « événements » suivants (avec la librairie Sax) : 

1. Début du document 

2. Début d’un élément « facture » 

3. Début d’un élément « montant » 

4. Texte « 432 » 

5. Fin d’un élément « montant » 

6. Début d’un élément « nom » 

7. Texte « Maman » 

8. Fin d’un élément « nom » 

9. Fin d’un élément « facture » 

10. Fin du document 

CC BY-NC-SA


La programmation événementielle peut être plus facile et plus fiable que le traitement 

du XML en tant que texte parce qu’au lieu de traiter chaque caractère, nous n’avons 

qu’à traiter ce qui est significatif pour le XML (balises de début et de fin, texte, etc.). Par 

exemple, les commentaires en XML seront automatiquement reconnus par un parseur 

événementiel. En fait, le parseur peut parfaitement omettre de générer un événement 

quand un commentaire est rencontré : c’est pourquoi les commentaires ne doivent jamais 

contenir des informations importantes. Les valeurs d’attributs par défaut, comme 

« surnom » dans l’exemple précédent, peuvent être traitées automatiquement. 

Le traitement événementiel implique quand même beaucoup de travail de la part du 

programmeur, particulièrement s’il doit prendre en compte plusieurs informations dans 

le document. Par exemple, s’il est nécessaire de connaître le contenu de tous les éléments 

du document XML, il faut enregistrer toutes ces informations, car le traitement 

événementiel ne permet pas les retours en arrière : le fichier est lu en séquence et nous 

devons faire le reste. 

Il y a des cas où le traitement événementiel est la meilleure solution. Lorsque nous 

devons traiter des fichiers XML très lourds, faisant plusieurs Mo, ou que l’on travaille 

sur des machines avec peu de mémoire (comme un téléphone cellulaire), ce type de 

traitement permet de faire une utilisation judicieuse de la mémoire vive. Un cas intéressant 

est celui où seuls quelques éléments d’un document XML nous intéressent. Par 

exemple, nous cherchons la valeur des éléments « nom » : le traitement événementiel 

permet de parcourir tout le document, mais de ne retenir que l’information voulue. 

En général, nous pouvons dire que la programmation événementielle du XML est réservée 

à des cas particuliers, tels les documents lourds, et aux experts. 

L’utilisation de SAX2 est fort simple à la base comme le montre le 

programme MonApplicationSAX. Il suffit de créer une classe dérivée de 

org.xml.sax.helpers.DefaultHandler où l’on surcharge des méthodes comme « startElement 

», « endElement » et « characters » qui nous permettent de gérer les événements 

« début d’un élément », « fin d’un élément » et « nœud de texte » respectivement. On 

peut aussi gérer d’autres événements comme le début du document (méthode « startDocument 

») et sa fin (méthode « endDocument »). Ce type de programmation orientéeobjet 

correspond au motif de l’observateur : on construit une classe qui est chargée de 

recevoir les différents événements et d’y réagir. Même les programmeurs expérimentés 

utilisent peu souvent ce type de motif. 


import org.xml.sax.*; 

import org.xml.sax.helpers.*; 

/** 

* INF 6450 

* Daniel Lemire 

*/ 

public class MonApplicationSAX extends DefaultHandler { 

/** 

CC BY-NC-SA


} 

* Événement correspondant au début d’un élément 

*/ 

public void startElement (String uri, String name, String qName, 

Attributes atts) { 

if(uri.length()>0) 

System.out.println("Début de l’élément "+uri+":"+qName); 

else 

System.out.println("Début de l’élément "+name); 

} 

/** 

* Événement correspondant à la fin d’un élément 

*/ 

public void endElement (String uri, String name, String qName) { 

if(uri.length()>0) 

System.out.println("Fin de l’élément "+uri+":"+qName); 

else 

System.out.println("Fin de l’élément "+name); 

} 

/** 

* Ici on traite l’événement correspondant à un noeud de texte 

*/ 

public void characters (char charac[], int debut, int longueur) { 

for (int i = debut; i < longueur+debut; ++i) 

System.out.print(charac[i]); 

System.out.println(); 

} 

/** 

* on traite un fichier offert en ligne de commande. 

* Utilisation: java MonApplicationSAX nomdufichier.xml 

*/ 

public static void main (String args[]) throws Exception { 

XMLReader xr = XMLReaderFactory.createXMLReader(); 

xr.setContentHandler(new MonApplicationSAX()); 

xr.parse(new InputSource(new FileReader(args[0]))); 

} 

CC BY-NC-SA


4.2.5 Traitement avec itérateurs 

Le traitement événementiel n’est pas très intuitif. Par contre, la plupart des programmeurs 

Java connaissent le traitement itératif. Voici un exemple très simple de programmation 

avec un itérateur : 

import java.util.*; 

public class myvec { 


Vector v= new Vector(); 

v.add("parent"); 

v.add("enfant"); 

Iterator i = v.iterator(); 

while(i.hasNext()) 

System.out.println(i.next()); 

} 

} 

Au lieu de créer une classe qui attend passivement de recevoir des événements, on fait 

une simple boucle. La Streaming API for XML (StAX) permet de faire un peu la même 

chose avec du XML. Voici un exemple, observez bien la présence d’une seule boucle 

et l’absence de plusieurs méthodes : 

// ce programme nécessite l’installation d’une 

// librairie StAX 

// voir http://dev2dev.bea.com/xml/stax.html 

// 

import javax.xml.stream.*; 

import java.net.*; 


public class staxex { 

public static void main(String[] args) { 

String input = args[0]; 

try { 

URL u = new URL(input); 

InputStream in = u.openStream(); 

XMLInputFactory factory = XMLInputFactory.newInstance(); 

XMLStreamReader parser = factory.createXMLStreamReader(in); 

for (int event = parser.next(); 

event != XMLStreamConstants.END_DOCUMENT; 

event = parser.next()) { 

switch (event) { 

case XMLStreamConstants.START_ELEMENT: 

System.out.println(parser.getLocalName()); 

break; 

case XMLStreamConstants.END_ELEMENT: 

CC BY-NC-SA


System.out.println(parser.getLocalName()); 

break; 

case XMLStreamConstants.CDATA: 

System.out.print(parser.getText()); 

break; 

} 

} 

parser.close(); 

} 

catch (XMLStreamException ex) { 

System.out.println(ex); 

} 

catch (IOException ex) { 

System.out.println(ex); 

} 

} 

} 

StAX est une norme Java officielle (JSR 173). La librairie open source Woodstox offre 

une implémentation de l’API StAX. 

4.2.6 Traitement avec modèle en arbre 

Un document XML peut être vu comme un arbre avec un élément-racine contenant luimême 

des éléments, qui eux-mêmes contiennent des éléments, et ainsi de suite. Ainsi, 

en utilisant le traitement événementiel par exemple, une librairie peut d’abord lire le 

document XML et créer un modèle en arbre. Le modèle en arbre XML le plus connu 

et qui sert de référence est le Document Object Model (DOM). Il est facile de trouver 

des librairies qui supportent le DOM ou une variante. Nous traiterons du DOM dans 

un prochain texte. 

Ainsi, étant donné le document XML suivant... 

 

 

 

 

]> 

432 


un modèle en arbre aura comme objet-racine un objet représentant le document luimême 

ayant comme enfant l’élément « facture ». Cet objet aura lui-même une liste 

CC BY-NC-SA


d’enfants, c’est-à-dire deux objets représentant les éléments « montant » et « nom ». La 

valeur d’attribut de « surnom » se trouvera dans l’objet représentant l’élément « nom ». 

De façon simpliste, nous pouvons représenter le document XML précédent avec le 

diagramme en arbre suivant : 

Document - déclaration de type 

| 

facture 

| | 

montant nom (surnom="Joe") 

| | 

"432" "Gérard Beauford" 

La programmation avec des modèles en arbre n’est pas toujours facile. Il y a un grand 

nombre d’objets à manipuler (un pour chaque élément de l’arbre) et donc beaucoup 

d’appels de fonctions. De plus, ce type de programmation exige beaucoup de mémoire 

parce que, généralement, le parseur va d’abord visiter le document en entier, le transformer 

en objets, puis tout stocker en mémoire. 

D’un autre côté, ce type de programmation (avec modèle en arbre) est sans doute 

l’une des façons les plus conviviales de traiter de petits fichiers XML à partir d’un 

langage orienté-objet comme Java. Il est relativement facile d’apprendre à écrire des 

programmes en Java pour traiter le XML, en utilisant le DOM. 

De la même façon, à partir d’un modèle en arbre, nous pouvons produire un document 

XML. Si nous utilisons une bonne librairie, nous sommes certains que le document 

XML généré sera bien formé et conforme à notre intention. Il faut par contre bien 

comprendre que le même modèle en arbre peut correspondre à plusieurs fichiers XML 

différents. Dans l’exemple précédent, il est possible qu’une librairie, qui a comme paramètre 

l’arbre que nous avons dessiné, génère un fichier XML comme celui-ci : 

 

432 


4.2.7 Transformations 

Le XSLT est une autre façon de traiter le XML par la programmation. Dans les cas les 

plus simples, c’est probablement le meilleur outil. Cependant, pour un traitement plus 

complexe, avec intégration dans un système d’information, il ne suffira généralement 

pas. Par exemple, le XSLT n’est pas conçu pour aller chercher des informations dans 

une base de données et les transformer en XML bien formé. 

CC BY-NC-SA


4.2.8 XPath 

Si nous devons extraire de l’information d’un document XML à partir d’un langage 

comme Java, il sera souvent plus simple d’utiliser une API qui supporte XPath. C’est 

le cas notamment du « SDK Java 1.5 ». Nous avons étudié les expressions XPath dans le 

module 3. Comme nous pouvons le voir avec l’exemple suivant, l’utilisation de XPath 

en Java requiert la création de plusieurs objets intermédiaires, ce qui n’est pas toujours 

très pratique. Le traitement XPath se fait sur un document chargé complètement en 

mémoire ce qui rend son application prohibitive sur de gros documents. Par contre, la 

syntaxe XPath est très expressive et peut éviter d’avoir à écrire de longs programmes 

Java. 

/* on doit toujours importer ces deux paquetages: */ 


import javax.xml.xpath.*; 

/* on doit construire une instance du document XML */ 

DocumentBuilderFactory dbfact = DocumentBuilderFactory.newInstance(); 

DocumentBuilder builder = dbfact.newDocumentBuilder(); 

/* on peut traiter directement un URL */ 

Document document = 

builder.parse("http://www.mondomaine.com/monfichier.xml"); 

/* on construit un objet XPath */ 

XPathFactory fact = XPathFactory.newInstance(); 

XPath xpath = fact.newXPath(); 

/* finalement, on peut émettre sa requête XPath sur le document */ 

String title = xpath.evaluate("//nom/text()", document); 

4.2.9 XML comme extension d’un langage 

Tout comme les structures de données simples, tel que les tableaux, font souvent partie 

intégrante des langages de programmation, on choisit parfois d’intégrer le traitement 

du XML à même le langage. À titre d’exemple, EAX (ECMAScript for XML) est une 

norme qui définit une extension du langage ECMAScript pour le traitement du XML. 

Avec ce type d’intégration, on peut définir un document XML directement dans le code 

comme dans cet exemple. 

var sales = 

 

 

 

; 

On peut aussi traiter les documents XML comme s’ils étaient des structures de données 

intégrées au langage, comme dans cet exemple. 

CC BY-NC-SA


for each( var price in sales..@price ) { 

alert( price ); 

} 

EAX est supporté par les implémentations du ECMAScript de Firefox (JavaScript) 

et de Flash (ActionScript). Ce n’est pas le seul exemple d’intégration du XML à un 

langage. 

4.2.10 Traitement par abstraction 

Nous pouvons utiliser des outils et des librairies qui n’exigent aucune connaissance du 

XML, mais qui peuvent utiliser et générer du XML. Par exemple, la plupart des bases 

de données relationnelles permettent d’importer et d’exporter des données en XML, 

sans jamais devoir manipuler le XML directement. Une entreprise pourra écrire sa 

propre librairie de traitement du XML dans le contexte d’une application XML spécifique. 

Par exemple, imaginons une application XML pour les factures; nous pourrions 

écrire une fonction qui prend en paramètre le montant et la personne à qui est destinée 

la facture, et qui génère le XML, sans que nous n’ayons même à savoir ce qu’est le 

XML. 

4.2.11 Sérialisation XML 

Comme exemple de traitement par abstraction, on a la sérialisation XML des objets en 

Java. On définit le terme sérialisation XML comme la transformation d’un objet Java 

en un fichier XML de manière à ce qu’on puisse reconstuire l’objet par la suite. On 

peut utiliser la sérialisation pour rapidement enregistrer des informations sur le disque 

ou transmettre des objets vers un autre programme au travers un réseau. Par exemple, 

le programme Serialization.java enregistre sur le disque un fichier XML contenant la 

description complète d’un objet « java.lang.String ». 

import java.beans.*; 


/** 

* INF 6450 

* Daniel Lemire 

*/ 

public class Serialization { 

/** 

* Écrit l’objet en XML dans le fichier spécifié 

* (ce qu’on appelle une "sérialisation") 

*/ 

public static void ecrireObjet(Object o, File f) throws IOException { 

CC BY-NC-SA


XMLEncoder e = new XMLEncoder( 

new BufferedOutputStream( 

new FileOutputStream(f))); 

e.writeObject(o); 

e.close(); 

} 

/** 

* Lit un objet "sérialisé" en XML dans le fichier spécifié 

*/ 

public static Object lireObjet(File f) throws IOException { 

XMLDecoder e = new XMLDecoder( 

new BufferedInputStream( 

new FileInputStream(f))); 

Object o = e.readObject(); 

e.close(); 

return o; 

} 

/** 

* lit un fichier et l’affiche à l’écran! 

*/ 

public static void affiche(File f) throws IOException { 

BufferedReader br = new BufferedReader(new FileReader(f)); 

String ligne; 

while((ligne = br.readLine()) != null) { 

System.out.println(ligne); 

} 

br.close(); 

} 

public static void main(String[] args) throws IOException { 

// je crée un objet java, dans ce cas, une chaîne de carac. 

String o = new String("Un objet java"); 

// je vais enregistrer le résultat dans un fichier XML 

File fichier = new File("test.xml"); 

ecrireObjet(o,fichier); 

affiche(fichier); 

Object lu = lireObjet(fichier); 

// ensuite, je vérifie que l’objet lu est bien identique 

// à l’objet écrit 

assert(lu.equals(o)); 

} 

} 

Après l’exécution de ce programme, le contenu du fichier XML « test.xml » est : 

CC BY-NC-SA


 

 

Un objet java 

 

On peut aussi utiliser la sérialisation avec ses propres objets à la condition qu’il s’agisse 

de « Beans » : tous les attributs de votre objet doivent être modifiés et lus par des 

méthodes qui débutent par « set » et « get » respectivement. Voici un exemple typique 

d’objet Bean qui peut facilement être sérialisé : 

public class UneClasse { 

int x, y; 

public UneClasse() { 

} 

public int getX() {return x;} 

public int getY() {return y;} 

public void setX(int i) {x=i;} 

public void setY(int i) {y=i;} 

} 

Voici un exemple de sérialisation XML de cet objet : 

 

 

 

 

1 

 

 

2 

 

 

 

Il faut, bien entendu, que le programme qui lit vos objets sérialisés ait accès aux classes 

de vos objets. 

4.2.12 Services web 

Bien qu’il ne s’agisse pas d’une façon de traiter du XML, les services web font partie 

intégrante des méthodes de programmation utilisant le XML. La définition même de ce 

qu’est un service web peut varier, mais pour l’essentiel, il s’agit d’un service pouvant 

être utilisé au sein d’application logicielle. Le service est généralement accessible sur 

le web et répond aux requêtes par du XML. On peut transmettre les requêtes sous 

diverses formes : requêtes HTTP simples (GET), transmission de documents XML, 

CC BY-NC-SA


etc. De nombreux sites web nous permettent d’utiliser des services web. Par exemple, 

Amazon, la librairie en ligne, vous permet d’utiliser un service web pour récupérer 

automatiquement les descriptions de produits. En principe, on peut combiner plusieurs 

services web pour composer des applications riches et originales, ou simplement pour 

ajouter une fonction particulière à un site web. Plusieurs protocoles peuvent être utilisés 

dont le Simple Object Access Protocol (SOAP) ou le Search/Retrieve via URL (SRU). 

On distingue généralement deux types de services web. Les services web « REST » 

tels que SRU se servent exclusivement du protocole HTTP et il est toujours possible 

de faire des requêtes en entrant simplement un URL dans un navigateur. Les services 

web REST font l’objet d’une spécification Java (Java Specification Request 311: Java 

API for RESTful Web Services). Les autres services web, dont ceux utilisant SOAP, 

exigent plutôt souvent que toutes les requêtes prennent la forme d’un fichier XML et 

ils ne tiennent pas compte particulièrement du protocole HTTP. 

Le protocole HTTP (RFC 2616) est relativement simple. Toutes les requêtes se font du 

client vers le serveur et se distinguent par un URI et une méthode. Votre navigateur fait 

des requêtes GET à chaque fois que vous chargez une page. La plupart des formulaires 

que vous utilisez sur le web emploie la méthode POST. On choisit généralement une 

des méthodes suivantes : 

Méthode 

GET 

POST 

PUT 

DELETE 

Explication 

Requête visant à obtenir la ressource 

(par exemple, un document XML) 

identifié par l’URI. Il s’agit du type de 

requête le plus utilisé: c’est celui utilisé 

généralement par les navigateurs 

pour charger les pages web. Une telle 

requête ne doit pas modifier l’état de la 

ressource. 

Ajouter une nouvelle ressource (un document, 

une image, un texte) en lien 

avec l’URI ou annoter ou modifier une 

ressource existante. L’URI fourni ne 

sera pas l’URI de la ressource si une 

nouvelle ressource est créée. 

Créer ou remplacer une ressource ayant 

l’URI fourni. En général, les requêtes 

PUT sont utilisées pour remplacer les 

ressources (comme un fichier XML). 

Supprimer une ressource (comme un 

document). 

Les méthodes GET, PUT et DELETE sont idempotentes : on peut répéter la requête 

autant de fois qu’on le désire, et on obtiendra le même résultat qu’une seule requête. 

La méthode POST, par contre, n’est pas idempotente : sa répétition pourrait entraîner 

la création ou la modification de ressources. La méthode GET est sécuritaire : on peut 

l’employer sans crainte de créer ou de modifier une ressource. 

CC BY-NC-SA


Un exemple de service web REST simple, utilisant le protocole SRU, est offert par la 

librairie du congrès du gouvernement américain. À l’aide d’une simple requêtre prenant 

la forme d’un URL, on peut demander de recevoir un fichier XML décrivant n’importe 

quel livre connu de la librairie. Voici un exemple de code Java fonctionnel permettant 

de faire une telle requête : 

import org.w3c.dom.*; 


import javax.xml.xpath.*; 

public class example { 

public static void main(String[] args) throws Exception { 

String base = "http://z3950.loc.gov:7090/voyager"; 

String autre = 

"operation=searchRetrieve&version=1.1&recordPacking=xml"; 

String autre2 = 

"&startRecord=1&maximumRecords=20&query="; 

String requete ="(dc.title=%22First Impressions of the New World%22) and 

(dc.creator all %22Trotter Isabella Strange%22)"; 

DocumentBuilderFactory factory = 

DocumentBuilderFactory.newInstance(); 

DocumentBuilder parser = factory.newDocumentBuilder(); 

Document doc = parser.parse(base+autre+autre2+requete); 

Element racine = doc.getDocumentElement(); 

XPathFactory fact = XPathFactory.newInstance(); 

XPath xpath = fact.newXPath(); 

System.out.println("code: "+xpath.evaluate("//leader/text()", doc)); 

} 

} 

En examinant le code, on peut voir qu’on cherche de l’information sur tous les livres 

ayant pour titre « First Impressions of the New World » et écrits par « Trotter Isabella 

Strange ». Le résultat de la requête SRU est plutôt incompréhensible dans ce cas précis. 

Il est surtout destiné aux spécialistes en bibliothéconomie : 

 

 

1.11 

 

info:srw/schema/1/marcxml-v1.1 

xml 

01007cam a2200265u 4500 

8662129 

20011206111958.0 

830108s1859 enkb a 000 0 eng 

 

CC BY-NC-SA


 

(DLC) 02002686 

 

 

0 

cbc 

premunv 

u 

ncip 

19 

y-gencatlg 

 

 

02002686 

 

 

DLC 

CarP 

DLC 

 

 

n-cn--- 

n-us--- 

 

 

E166 

.T85 

 

 

Microfilm 32043 E 

 

 

[Trotter, Isabella (Strange)], 

1816-1878. [from old catalog] 

 

 

First impressions of the New world on two travellers 

from the Old, in the autumn of 1858. 

 

 

London, 

Longman, Brown, Green, Longmans, & 

Roberts, 

1859. 

 

 

CC BY-NC-SA


xi, 308 p. 

front. (fold. map) 

20 cm. 

 

 

Replace; 

LC copy replaced by preservation microfilm 

DLC 

 

 

United States 

Description and travel. [from old catalog] 

 

 

Canada 

Description and travel. [from old catalog] 

 

 

pmosl 

 

 

mvp 

zz01 

 

 

c-MicRR 

Microfilm 32043 E 

Copy 1 

PREM 

 

1 

Pour une description, des services web utilisant SOAP, vous pouvez consulter la rubrique 

correspondante sur wikipédia. Ils sont généralement plus complexes que les 

services web REST. 


1. Si vous faites la lecture d’un document XML avec une librairie supportant DOM 

et que, par la suite, vous utilisez la même librairie pour sauvegarder exactement 

le même modèle en arbre, est-ce que le fichier nouvellement produit sera identique 

au fichier d’origine Choisissez la bonne réponse parmi les choix suivants. 

(a) Oui 

(b) Non 

CC BY-NC-SA


2. Si vous voulez absolument produire du XML bien formé, quelle est la meilleure 

méthode Choisissez la bonne réponse parmi les choix suivants. 

(a) En traitant le XML comme du texte (System.out en Java). 

(b) En utilisant le XSLT. 

(c) En utilisant une librairie avec modèle DOM. 

3. Est-ce qu’une librairie événementielle nous avertit de la présence d’un commentaire 

dans le texte XML Est-ce que le modèle en arbre doit contenir les commentaires 


(a) Oui. Dans les deux cas. 

(b) Non. Dans les deux cas. 

4. Quel type de modèle est le DOM Choisissez la bonne réponse parmi les choix 

suivants. 

(a) En arbre 

(b) Événementiel 

(c) Texte 

5. Si, dans un document XML, seule la valeur des attributs « montant » vous intéresse, 

quelle serait le meilleur modèle de programmation Choisissez la bonne 


(a) En arbre 

(b) Événementiel 

(c) Texte 


1. (a) Il y a plusieurs façons de représenter un même arbre XML. Par 

exemple, l’espace entre les éléments n’est pas significatif en XML et 

« fdsfds » est équivalent à « fds 

fds ». 

(b) (Bonne réponse) Effectivement, il peut y avoir des différences. 

2. (a) S’il est important que votre document soit bien formé, ce n’est probablement 

pas la meilleure méthode, à moins que le travail ne soit relativement 

simple. 

(b) Non. Le XSLT ne permet pas de vérifier que le document produit est du 

XML bien formé. Il est possible de générer du XML incorrect à partir du 

XSLT : par exemple, ayant deux éléments-racines. 

(c) (Bonne réponse) Oui. Une bonne librairie devrait nous assurer que le document 

produit est du XML bien formé. 

CC BY-NC-SA

Rappel sur la programmation Java 299 

3. (a) Non. C’est pourquoi les commentaires ne devraient pas contenir des informations 

importantes, car les parseurs peuvent omettre les commentaires. 

(b) (Bonne réponse) Effectivement. Certains parseurs omettent les commentaires; 

si les les commentaires XML servent à stocker des informations 

importantes, cela peut entraîner un problème. 

4. (a) (Bonne réponse) Oui. C’est même le modèle en arbre de référence. 

(b) Non, mais on peut utiliser un traitement événementiel pour produire 

un DOM. 

(c) Non. 

5. (a) Non. Il peut être fastidieux et coûter beaucoup de mémoire que de tout 

mettre dans un arbre pour n’aller chercher que quelques valeurs. 

(b) (Bonne réponse) Effectivement. Vous pourriez ainsi aller chercher que ce 

dont vous avez besoin. 

(c) Le traitement du XML comme texte peut fonctionner dans certains cas 

simples, mais pas en général. 

4.3 Rappel sur la programmation Java 


Ramener à votre mémoire les notions que vous connaissez déjà sur le langage de programmation 

Java. 


Lisez les définitions qui suivent, puis compilez et exécutez les programmes suggérés 

dans la section « Exemples ». 

4.3.3 Définitions 

Notion d’objet 

Java est un langage orienté objet. Le terme « orienté objet » signifie que l’on modélise 

le problème en utilisant des « objets ». Les objets possèdent des données (les attributs) 

et des comportements (les méthodes). Dans la plupart des langages orientés objets, les 

objets appartiennent à une « classe » qui en définit le type. 

CC BY-NC-SA


Notion de classe 

Une classe est un modèle pour créer des objets qui ont des caractéristiques communes. 

La classe comporte la structure d’un objet (ses attributs et ses méthodes). On dit qu’un 

objet est l’instance d’une classe et on parle d’instanciation. En Java, tous les objets sont 

créés à partir d’une classe. 

Notion de méthode 

Une méthode est une fonction qui peut être appliquée aux objets ou qui est appliquée 

par les objets. Par exemple, pour une classe « Voiture », une méthode pourrait être 

« Freiner » ou « Accélérer ». 

Notion d’interface 

Une interface est définie par un ensemble de méthodes et de variables à la manière 

d’une classe; mais, à la différence d’une classe, on ne peut l’utiliser comme modèle 

pour créer un objet. On dit d’une classe qui contient toutes les méthodes spécifiées par 

l’interface qu’elle implémente l’interface en question. 

En pratique, l’interface peut se traiter comme une classe : si la classe « Voiture » implémente 

l’interface « Vehicule », alors tous les objets instanciés à partir de « Voiture » 

peuvent être traités comme des objets de type « Vehicule ». Une même classe peut 

implémenter plusieurs interfaces. 

Notion d’héritage 

L’héritage est un lien entre des classes. Si une classe est créée à partir d’une classe 

déjà existante, elle « hérite » de ses attributs et de ses méthodes. Par exemple, la classe 

« voiture » pourrait hériter de la classe « engin ». 

Notion d’encapsulation 

L’encapsulation consiste à protéger un objet, en empêchant l’accès à ses données par 

un autre moyen que les méthodes proposées. 

4.3.4 Exemples 

Les deux exemples proposés sont très simples. Toutefois, faites-les pour vous remémorer 

la programmation Java. 

CC BY-NC-SA

Rappel sur la programmation Java 301 

Commençons par le commencement. Créons un programme qui affichera « Bonjour ! ». 

Tapez le texte suivant, avec Notepad/Bloc-notes, et enregistrez-le sous le nom « bonjour.java 

». 

public class bonjour{ 

public static void main (String[] args){ 

System.out.println("Bonjour !"); 

} 

} 

Pour tester ce programme, ouvrez une fenêtre de commande et placez-vous dans le 

dossier où vous avez enregistré le fichier « bonjour.java », puis tapez « javac bonjour.java 

» pour compiler le programme. N’oubliez pas d’indiquer le chemin du fichier 

« javac.exe »; au besoin, par exemple, tapez, dans la fenêtre de commande, 

« PATH=C:/j2sdk1.4.2_06/bin », suivi d’un retour du chariot. Cette commande va 

créer un fichier « bonjour.class » qui contient le programme compilé. Pour exécuter 

le programme, il suffit de taper « java bonjour ». Normalement, le texte « Bonjour ! » 

s’affichera. 

Créons maintenant un autre programme qui prend comme argument le nom d’une personne 

et qui affiche « Bonjour nom ! ». Il suffit de modifier le programme précédent. 

Nommons ce programme « bonjourbis » et le fichier « bonjourbis.java ». 

public class bonjourbis{ 

public static void main (String[] args){ 

String nom = new String(args[0]); 

System.out.println("Bonjour "+nom+" !"); 

} 

} 

Pour compiler le fichier, il suffit de taper « javac bonjourbis.java ». Pour l’exécuter 

avec « Lucie » comme argument, il suffit d’ajouter l’argument à la fin de la ligne de 

commande : « java bonjourbis Lucie ». Et le texte « Bonjour Lucie ! » s’affichera. 

4.3.5 Exemples avancés 

Supposons que Voiture et Bicyclette sont des classes qui héritent de Vehicule ou alors, 

des classes qui implémentent l’interface Vehicule. Supposons que vous avez un objet 

de type Vehicule, comment savoir s’il s’agit d’un objet de classe Voiture ou Bicyclette 

Vous pouvez tester son type avec le mot-clef « instanceof », comme ceci : 

public void afficheType (Vehicule v){ 

if(v instanceof Voiture) { 

System.out.println("Objet de classe Voiture!"); 

} else if (v instanceof Bicyclette) { 

System.out.println("Objet de classe Bicyclette!"); 

} else { 

System.out.println("Erreur!"); 

CC BY-NC-SA


} 

} 

Supposons maintenant qu’on vous passe un objet de type Vehicule alors que vous savez 

très bien que c’est un objet de classe Voiture, ça peut être bien embêtant surtout si 

l’objet Voiture a des méthodes ou attributs que le type Vehicule n’a pas ! Vous pouvez 

dire à Java, explicitement, que vous voulez qu’il traite l’objet comme ayant la classe 

Voiture comme ceci : 

public void traiteType (Vehicule v){ 

Voiture w = (Voiture) v; 

(...) 

} 

Attention cependant ! Si l’objet n’est pas de la classe Voiture, une exception sera générée 

(ClassCastException). 

4.3.6 Lecture de fichiers 

On peut lire un fichier au format text en Java, ligne par ligne, en utilisant la classe 

BufferReader du paquetage java.io. 


(...) 

BufferedReader br = new BufferedReader( 

new InputStreamReader(new FileInputStream(nomdufichier))); 

String ligne; 

while ((ligne = br.readLine()) != null) { 

(...) 

} 

br.close(); 

4.3.7 Astuces 

– La casse est importante en Java. La variable « i » n’est pas la même que la variable 

« I ». 

– Votre fichier java ne peut contenir qu’une seule classe « public » et le fichier doit 

avoir le même nom que cette classe. 

– Les instructions, dans une fonction, doivent être séparées par le point-virgule ( ; ). 

4.3.8 Retour sur l’activité 

Est-ce que vous avez pu compiler et exécuter les programmes en java Si oui, passez 

aux autres activités, sinon contactez la personne tutrice ou cherchez encore un peu. 

CC BY-NC-SA

Tutoriel sur DOM 303 

4.4 Tutoriel sur DOM 


– Apprendre à lire et à écrire du XML à partir de Java. 

– Comprendre le modèle DOM, en particulier sa structure en arbre. 


Ce tutoriel vous fournira une compréhension pratique de DOM (version 2.0) en Java. 

Lisez attentivement le texte qui suit et, au fur et à mesure, faites les exemples proposés. 

4.4.3 Le tutoriel pour se familiariser avec le DOM 

Introduction 

Nous supposons que vous disposez d’un environnement de développement Java et que 

vous ferez les exemples de ce tutoriel afin de mieux comprendre. Notre objectif est 

avant tout de vous rendre suffisamment à l’aise avec DOM pour pouvoir l’utiliser; nous 

vous invitons toutefois à naviguer dans le web pour en apprendre davantage sur le sujet, 

au besoin. 

L’API Java elle-même est disponible sur le site de Sun Microsystems. Pour pouvoir 

faire vos propres programmes, consultez l’API Java qui comprend tous les objets et 

fonctions du tutoriel. 


On dit qu’un modèle DOM est une structure en arbre. En informatique, un arbre est 

un graphe ou une structure constituée de nœuds, de façon telle que chaque nœud a un 

et un seul parent - ou aucun -, lequel a un seul ou plusieurs enfants. Un seul nœud est 

autorisé à ne pas avoir de parent, c’est le nœud-racine. Pour illustrer notre propos, nous 

pouvons penser à une cellule qui se divise : chaque cellule a une et une seule celluleparente, 

et chaque cellule peut se diviser (souvent en deux) ou mourir avant de pouvoir 

se diviser. On dit d’un nœud qui n’a pas d’enfant qu’il est un nœud-feuille. 

Comme nous allons le voir, dans un arbre DOM, tous les éléments, les déclarations 

XML, etc., sont représentés par un nœud. Le nœud-racine est le document lui-même 

qui peut contenir la déclaration XML, la déclaration de type de document et l’élémentracine, 

comme ses enfants. 

CC BY-NC-SA



L’API DOM est très utilisée. Elle est supportée dans plusieurs langages, dont ECMAScript, 

Java, C#, C++, etc. parce qu’elle a été spécifiée avec l’Interface description language. 

Par contre, comme c’est un traitement du XML en arbre, les implémentations 

de l’API DOM consomment beaucoup de mémoire. En plus, l’API DOM fait travailler 

le programmeur en exigeant beaucoup de lignes de code pour faire les choses les plus 

simples. Il arrive aussi qu’une implémentation de l’API DOM soit beaucoup plus lente 

que des alternatives plus simples. Malgré tous ces défauts, le fait que l’API DOM soit 

si bien supportée en fait une référence incontournable. 

4.4.6 Un document XML 

Créons d’abord un document XML, que nous nommerons « test.xml », et un répertoire 

pour y déposer le fichier en question, ainsi que le code Java pour ce tutoriel. 

 

 

 

Jean 

32 

 

 

Marie 

54 

 

 

4.4.7 Charger un document XML en Java 

Écrivons maintenant un programme en Java qui va lire ce fichier XML. Pour ce 

faire, créons avec Notepad/Bloc-notes ou avec tout autre éditeur approprié, un fichier 

« test.java » contenant le texte suivant : 



public class test { 





Document doc = parser.parse(args[0]); 

} 

} 

CC BY-NC-SA


Ensuite, compilons et exécutons le programme : 

javac test.java 

java test test.xml 

Si tout se passe bien, vous ne devriez rien voir s’afficher sur votre écran. En effet, les 

trois lignes de code Java utilisées plus haut ne font que créer l’objet « Document » qui 

contient, selon un modèle en arbre, notre document « test.xml ». 

Java utilise un traitement événementiel (SAX) pour charger le fichier. Cependant, une 

fois que l’objet doc a été créé, vous pourriez effacer le fichier du disque sans mal. Le 

traitement du document se fait entièrement en mémoire. 

4.4.8 Accès à l’élément-racine 

Le premier élément que nous voulons consulter est l’élément-racine qui, dans notre 

cas, est un élément « liste ». Nous obtiendrons le résultat désiré en utilisant la méthode 

« getDocumentElement », comme ceci : 










} 

} 

Cet exemple n’est pas très intéressant puisque, encore une fois, rien ne s’affiche à 

l’écran. Par contre, nous avons maintenant un objet « racine » qui est un modèle de 

l’élément-racine du document XML et qui a le type d’une interface « Element ». 

L’interface « Element » est l’interface la plus importante en DOM. Notre nouvel objet 

« racine » a une méthode « getTagName() » qui permet de connaître le nom de 

l’élément. Par exemple, le code suivant devrait afficher le texte « liste » à l’écran. 








CC BY-NC-SA


} 

} 



System.out.println(racine.getTagName()); 

Voici deux des méthodes importantes de l’interface « Element » : 

Méthode 

Résultat 

getTagName() 

Donne le nom de l’élément 

getAttribute(String nom) 

Donne la valeur d’un attribut 

Point technique : Dans le cas où vous devez faire afficher du texte en ligne de commande 

sous un environnement Windows, il arrive que les accents ne passent pas. En 

effet, le jeu de caractère utilisé par l’outil de ligne de commande Windows est souvent 

Cp850. Il faut donc en informer Java en ajouter la ligne « System.setOut(new PrintStream(System.out, 

true, "Cp850")); » avant d’utiliser la méthode System.out. 

4.4.9 L’interface « Node » 

Dans le modèle DOM, l’arbre est un arbre fait de nœuds ou « nodes », en anglais. 

Plusieurs choses sont représentées par l’interface « Node » : du texte, un élément, 

une instruction de traitement, une déclaration de type de document, une entité, etc. 

L’arbre DOM commence à la racine par le document lui-même. Les attributs peuvent 

être traités comme des « Node », même s’ils ne font pas partie de l’arbre DOM : un 

attribut est une propriété d’un élément de l’arbre. Le modèle en arbre DOM peut être 

décrit ainsi : un document contient des « Node », et chaque « Node » contient d’autres 

« Node », etc. 

L’interface « Node » possède deux méthodes très importantes : « getNodeName() » 

et « getNodeValue() ». La valeur donnée par l’une ou l’autre de ces deux méthodes 

dépend du type de nœud représenté. Le tableau suivant résume le comportement de ces 

méthodes pour différents types importants : 

type de nœud nom DOM valeur de getNodeName() 

valeur de getNodeValue() 

attribut Attr nom de l’attribut valeur de l’attribut 

élément Element nom de l’élément null 

instruction de traitemention 

ProcessingInstructioncible de l’instruc- 

contenu entier de 

l’instruction sans 

la cible 

texte Text la chaîne « #text » le texte 

Une autre méthode importante est « getNodeType ». Par exemple, si « e » est un nœud 

et que nous voulons vérifier s’il s’agit d’un élément, nous pouvons le faire comme ceci : 

if( e.getNodeType() == Node.ELEMENT_NODE) { 

CC BY-NC-SA


System.out.println(" Ce noeud est un élément!!! "); 

} 

Demandons maintenant à DOM de nous fournir tous les sous-éléments « joueur » de 

l’élément-racine, comme ceci : 










NodeList nl = racine.getElementsByTagName("joueur"); 

} 

} 

Nous avons utilisé la méthode « getElementsByTagName » qui nous permet d’obtenir 

la liste des sous-éléments ayant le nom XML donné. Une alternative est d’utiliser la 

méthode « getElementById » qui donne le seul élément ayant un attribut de type « ID » 

correspondant à la chaîne de caractères founie. En XHTML, par exemple, on peut ajouter 

un attribut nommé « id » qui a comme une valeur « ID ». Rappelons qu’un attribut 

a une valeur de type « ID » si elle est un nom XML et si toutes les valeurs de type 

« ID » dans le document sont différentes. L’avantage sur la méthode « getElementsBy- 

TagName » est qu’on peut rapidement sélectionner un unique élément. 

L’interface « NodeList » est, quant à elle, très simple. Elle n’a que deux méthodes : 

« getLength() », qui retourne le nombre de « Node », et « item(int) », qui nous donne 

accès au « Node » en question. Donc, pour visiter tous les sous-éléments de l’élémentracine, 

nous pouvons faire comme ceci : 







DocumentBuilder parser = 

factory.newDocumentBuilder(); 



NodeList nl = racine.getChildNodes(); 

for (int i = 0; i < nl.getLength(); ++i) { 

Node n = nl.item(i); 

CC BY-NC-SA


} 

} 

} 

Les deux sous-éléments « joueur » de l’élément « liste » sont visités. Parce que les 

deux « Node » en question sont des éléments, nous aurions très bien pu écrire : 













Element n = (Element) nl.item(i); 

} 

} 

} 

Supposons maintenant que nous voulions afficher le contenu des deux éléments 

« joueur ». Nous pouvons y arriver en commençant comme ceci : 













Element joueur = (Element) nl.item(i); 

NodeList listedenoms = joueur.getElementsByTagName("nom"); 

Element nom = (Element) listedenoms.item(0); 

} 

} 

} 

CC BY-NC-SA


En principe, nous avons maintenant les éléments « nom » des joueurs, mais comment 

faire pour obtenir le contenu textuel d’un élément Nous devons savoir que 

le texte est lui-même un « Node ». Il suffit donc de sélectionner le premier et seul 

« Node » contenu dans l’élément « nom » et d’aller en chercher la valeur (getFirst- 

Child().getNodeValue()), comme ceci : 
















System.out.println(nom.getFirstChild().getNodeValue()); 

} 

} 

} 

Essayez maintenant ce programme. Vous devriez voir les noms des joueurs qui s’affichent. 

Si vous souhaitez ajouter le nombre de buts correspondant à chaque joueur, 

rien de plus facile! Il suffit de répéter le code comme dans l’exemple qui suit : 
















CC BY-NC-SA


} 

} 

} 


NodeList listedebuts = joueur.getElementsByTagName("buts"); 

Element buts = (Element) listedebuts.item(0); 

System.out.println(buts.getFirstChild().getNodeValue()); 

Dans l’éventualité ou un élément nom ne contiendrait pas de texte, la méthode 

getFirstChild() retourne la valeur null. Il faudrait donc cette éventualité 

(buts.getFirstChild()==null) afin d’éviter un plantage du programme. 

Vous vous rappelez sans doute que les éléments « nom » ont un attribut « surnom ». 

Pour aller en chercher la valeur, il suffit d’utiliser la méthode « getAttribute » comme 

ceci : 

















System.out.println(nom.getAttribute("surnom")); 

NodeList listedebuts = joueur.getElementsByTagName("buts"); 

Element buts = (Element) listedebuts.item(0); 

System.out.println(buts.getFirstChild().getNodeValue()); 

} 

} 

} 

Nous constatons que les attributs ne sont pas des « Node » et qu’ils sont donc plutôt 

traités comme faisant partie d’un élément. C’est logique; puisqu’un attribut ne peut 

contenir d’autres attributs, il ne forme donc pas un élément essentiel d’une structure en 

arbre, contrairement aux éléments. 

Et c’est tout ce qu’il nous faut pour lire complètement le fichier XML « test.xml ». 

Vous pouvez bien sûr créer un programme plus sophistiqué! 

CC BY-NC-SA


4.4.10 Création de documents 

À partir d’une structure DOM, nous pouvons créer un document XML en Java à l’aide 

de quelques lignes et du paquetage « javax.xml.transform » et de ses sous-paquetages. 

L’écriture d’une structure DOM se fait vers un objet de type « Writer ». Si nous voulons 

écrire dans un fichier, nous devons créer un « FileWriter » et si nous voulons afficher à 

l’écran, nous passerons en paramètre l’objet « System.out ». 

Par exemple, pour lire le document « test.xml », en faire une structure DOM et l’enregistrer, 

nous pouvons utiliser le programme suivant : 




import javax.xml.transform.*; 

import javax.xml.transform.dom.*; 

import javax.xml.transform.stream.*; 

public class construction { 


// lecture d’un document 






// écriture d’un document 

TransformerFactory tfact = 

TransformerFactory.newInstance(); 

Transformer transformer = 

tfact.newTransformer(); 

DOMSource source = new DOMSource(doc); 

FileWriter fw = new FileWriter(args[1]); 

StreamResult result = new StreamResult(fw); 

transformer.transform(source, result); 

} 

} 

Pour afficher à l’écran, nous aurions pu utiliser la syntaxe « new StreamResult(System.out); 

». 

Si nous enregistrons ce code Java dans un fichier nommé « construction.java », il suffira 

ensuite de taper : 

javac construction.java 

java construction test.xml copy.xml 

CC BY-NC-SA


Le fichier qui en résulte, « copy.xml », devrait être pratiquement identique à 

« test.xml ». Nous pouvons évidemment utiliser cette approche pour créer des documents 

XML. 

Nous allons maintenant créer un document XML « vide », avant de lui ajouter du 

contenu. Nommons le fichier du programme « construction2.java ». Nous utilisons la 

méthode « newDocument » : 







public class construction2 { 






Document doc = parser.newDocument(); 

} 

} 

Si nous enregistrons ce document, il n’y aura que la déclaration XML. Créons maintenant 

un élément « liste » et ajoutons-le à notre document. Pour ce faire, nous utiliserons 

la méthode « createElement » de l’interface « Document » 

et la méthode « appendChild », comme ceci : 














Element liste = doc.createElement("liste"); 

doc.appendChild(liste); 

} 

CC BY-NC-SA


} 

Il est important de noter qu’on ne peut créer un élément ou autre nœud sans avoir 

d’abord un document. Un nœud DOM contient toujours une référence au document 

auquel il appartient, même si on ne l’a pas encore inséré dans le document avec une 

fonction « appendChild ». Il est impossible de prendre un élément d’un document et de 

l’insérer dans un autre document : vous risquez ainsi de vous retrouver avec un document 

dysfonctionnel. On peut cependant copier un nœud d’un document pour l’amener 

dans un nouveau document avec la méthode « importNode » de l’interface « Document 

». 

Nous pouvons donc créer un nouveau fichier avec le contenu de « test.xml », entièrement 

à partir de fonctions en Java. À chaque nœud, nous pouvons ajouter des enfants 

à l’aide de la méthode « appendChild ». Nous pouvons aussi créer des nœuds de texte 

à partir de la méthode « createTextNode » de l’interface « Document ». Finalement, 

l’interface « Element » a une méthode « setAttribute » pour créer un attribut. 

Comme nous utilisons souvent « ISO-8859-1 » pour l’encodage de caractères, nous 

vous suggérons de spécifier l’attribut « encoding » du document XML, comme ceci : 





transformer.setOutputProperty("encoding", "ISO-8859-1"); 

Le programme suivant va créer un document « nouveaufichier.xml » équivalent au 

fichier « test.xml » défini plus haut. Nous appellerons le fichier « construction3.java ». 














Element liste = doc.createElement("liste"); 

doc.appendChild(liste); 

Element joueur1 = doc.createElement("joueur"); 

Element joueur2 = doc.createElement("joueur"); 

liste.appendChild(joueur1); 

liste.appendChild(joueur2); 

CC BY-NC-SA


} 

} 

Element nom1 = doc.createElement("nom"); 

nom1.appendChild(doc.createTextNode("Jean")); 

Element nom2 = doc.createElement("nom"); 

nom2.appendChild(doc.createTextNode("Marie")); 

joueur1.appendChild(nom1); 

joueur2.appendChild(nom2); 

Element but1 = doc.createElement("buts"); 

but1.appendChild(doc.createTextNode("32")); 

Element but2 = doc.createElement("buts"); 

but2.appendChild(doc.createTextNode("54")); 

joueur1.appendChild(but1); 

joueur2.appendChild(but2); 

nom1.setAttribute("surnom","jojo"); 

nom2.setAttribute("surnom","Ma"); 







FileWriter fw = new FileWriter("nouveaufichier.xml"); 



Testez ce programme et modifiez-le pour explorer différentes possibilités. Il peut être 

utile de vérifier les fonctions disponibles dans le cadre de l’API Java. 

Il est intéressant d’observer qu’il est possible d’ajouter à plusieurs reprises un nœud de 

texte à même un élément : 

e.appendChild(doc.createElement("a")); 

e.appendChild(doc.createElement("b")); 

e.appendChild(doc.createElement("c")); 

Le contenu de l’élément, dans cet exemple, sera tout simplement le texte « abc » décomposé 

en 3 nœud. 

4.4.11 Modifier un « Document » 

Nous observons que l’écriture d’un document XML se fait à partir d’un objet « Document 

». Rien ne nous empêche donc de charger un document XML, de le modifier et 

de l’enregistrer à nouveau. 

Voici un tableau qui donne quelques fréquentes opérations de modification : 

CC BY-NC-SA


Code 

e.getParentNode().removeChild(e); 

e.getParentNode().replaceChild(e,f); 

e.setAttribute(String nom, String valeur) 

e.removeAttribute(String nom) 

Résultat 

Permet d’éliminer un nœud 

Permet de remplacer un nœud par un 

autre 

Permet de modifier un attribut 

Permet d’éliminer un attribut 

Par exemple, le programme suivant, « Modif.java », permet d’ajouter un attribut à 

l’élément-racine de tout document XML : 







public class Modif { 

} 








racine.setAttribute("unattribut","une valeur"); 







FileWriter fw = new FileWriter(args[0]); 



} 

Il suffit de l’appeler avec la syntaxe « java Modif monfichier.xml ». 

CC BY-NC-SA



L’utilisation des espaces de noms est prévue en DOM (version 2.0). Par exemple, pour 

créer un élément appartenant à un espace de noms, il faut utiliser la syntaxe « createElementNS(String 

espace, String nom) », où « espace » prend la valeur de l’URI 

et « nom » contient le préfixe et le nom de l’élément. Cette nouvelle méthode vient 

remplacer le simple « createElement(String nom) ». Il existe aussi une méthode correspondante 

« setAttributeNS(String espace, String nom, String valeur) ». 

Considérons l’exemple de document XML suivant : 

 

 

 

Pour le produire en DOM, il faudrait utiliser un code comme celui-ci : 







public class Espace { 


String uri= "http://www.mondomaine.com/"; 






Element racine = doc.createElementNS(uri,"md:racine"); 

racine.setAttribute("xmlns:md",uri); 

doc.appendChild(racine); 

Element e = doc.createElementNS(uri,"md:element"); 

racine.appendChild(e); 

e.setAttributeNS(uri,"md:unattribut","sa valeur"); 







StreamResult result = new StreamResult(System.out); 


CC BY-NC-SA


} 

} 

Il faut nommer le fichier « Espace.java ». 

Nous pouvons aussi retrouver l’espace de noms d’un élément à l’aide de la méthode 

« getNamespaceURI() » de l’interface « Node ». Cependant, par défaut, la classe « DocumentBuilderFactory 

» ignore les espaces de noms et il faut, par conséquent, ajouter la 

ligne « factory.setNamespaceAware(true); ». L’exemple du code qui suit donne l’espace 

de noms (URI), le préfixe et le nom de l’élément (avec le préfixe) de tout fichier XML 

saisi dans une ligne de commande : 



public class LireEspace { 

} 




factory.setNamespaceAware(true); 




System.out.println(racine.getNamespaceURI()+" " 

+racine.getPrefix()+" "+ racine.getTagName()); 

} 

Il faut nommer le fichier « LireEspace.java », et l’exécuter avec la syntaxe « java LireEspace 

monfichier.xml ». 

4.4.13 Deux problèmes avec solution 

Pour vous aider à maîtriser le modèle DOM, nous vous proposons deux problèmes et 

une solution possible pour chacun. 

Problème 1 

Créez une classe « Arbre » (fichier « Arbre.java ») qui donne l’arbre DOM d’un document 

XML. Pour chaque nœud, donnez son nom et sa valeur (indices : « getNode- 

Name », « get NodeValue »). Enfin, indentez les nœuds selon le nombre de parents 

qu’ils ont. 

Ainsi, étant donné le fichier « test.xml » suivant : 

CC BY-NC-SA


 

Jean32 

La commande « java Arbre test.xml » devrait afficher à l’écran le résultat suivant : 

Nom: #document Valeur: null 

Nom: joueur Valeur: null 

Nom: nom Valeur: null 

Nom: #text Valeur: Jean 

Nom: buts Valeur: null 

Nom: #text Valeur: 32 

Solution du problème 1 

Voici une solution possible : 



public class Arbre { 

public static void traite(Node node, int i) { 

String s= ""; for (int k = 0; k < i; ++k) s+=" "; 

System.out.println(s+"Nom: "+ node.getNodeName() + 

" Valeur: "+node.getNodeValue()); 

NodeList nl = node.getChildNodes(); 

if(nl != null) { 

for (int k = 0; k < nl.getLength(); ++k) { 

traite( nl.item(k),i+2); 

} 

} 

} 






traite(doc,0); 

} 

} 

CC BY-NC-SA


Problème 2 

Nous pouvons utiliser un fichier XML comme archive d’une base de données primitive. 

Cette fois-ci, nous vous demandons d’écrire un programme qui permet de chercher, 

d’effacer et d’ajouter des noms dans un bottin téléphonique. 

Stockez les numéros dans un fichier XML nommé « bottin.xml » et ayant le contenu 

qui suit : 

 

 

 

 

 

Concevez un programme dont le code source sera contenu dans un fichier nommé 

« Bottin.java ». Votre programme doit posséder les trois fonctions suivantes : 

– « java Bottin efface "Jean Réjean" » : élimine du fichier « bottin.xml » tout élément 

« personne » ayant comme attribut « nom="Jean Réjean" ». 

– « java Bottin cherche "Jean Réjean" » : donne le numéro de téléphone correspondant 

au nom donné à partir du contenu du fichier « bottin.xml », et ne retourne rien si le 

nom donné n’est pas trouvé. 

– « java Bottin ajoute "Jean Réjean" 432-4421 » : fait en sorte que le nom « Jean 

Réjean » soit associé au seul numéro de téléphone « 432-4421 ». 

Vous pouvez supposer que le fichier « bottin.xml » existe et se trouve dans le même répertoire 

que le fichier « Bottin.java ». Vous pouvez également supposer que l’élémentracine 

est « bottin ». 

Solution du problème 2 

Voici une solution possible : 







public class Bottin { 




factory.setNamespaceAware(true); 


CC BY-NC-SA



Document doc = parser.parse("bottin.xml"); 



if(args[0].equals("efface")) { 


if(nl.item(k).getNodeType()==Node.ELEMENT_NODE) { 

Element e = (Element) nl.item(k); 

if(e.getAttribute("nom").equals(args[1])) { 

e.getParentNode().removeChild(e); 

} 

} 

} 

} else if (args[0].equals("cherche")) { 





System.out.println(e.getAttribute("téléphone")); 

} 

} 

} 

} else if (args[0].equals("ajoute")) { 

boolean ajout = false; 





e.setAttribute("téléphone",args[2]); 

ajout=true; 

} 

} 

} 

if( ! ajout) { 

Element p = doc.createElement("personne"); 

p.setAttribute("nom", args[1]); 

p.setAttribute("téléphone", args[2]); 

racine.appendChild(p); 

} 

} 

TransformerFactory tfact = TransformerFactory.newInstance(); 

Transformer transformer = tfact.newTransformer(); 



FileWriter fw = new FileWriter("bottin.xml"); 


CC BY-NC-SA


} 


} 

4.4.14 DOM et ECMAScript 

ECMAScript est un langage similaire au Java quant à sa syntaxe de base et qui s’exécute 

souvent dans un navigateur. Il fut inventé par Netscape en 1995 sous le nom de 

JavaScript. Il s’agit d’une norme de l’European Computer Manufacturers Association 

(ECMA) depuis 1997. L’implémentation du ECMAScript que l’on retrouve dans le 

navigateur Firefox se nomme toujours JavaScript, alors que Microsoft nomme son implémentation 

JScript. L’ECMAScript n’est pas une forme de Java, même s’ils ont une 

ressemblance superficielle, adoptant tous les deux une syntaxe proche du langage C. Il 

existe de nombreux tutoriels sur le ECMAScript incluant le tutoriel de Jean-Paul Davalan 

se trouvant à l’URL http://perso.wanadoo.fr/jean-paul.davalan/lang/jsc/ ou encore 

le tutoriel de commentcamarche.net. Le site xul.fr offre un résumé du langage, le site 

mozilla.org offre une description complète du langage (en anglais). 

Si vous ne connaissez pas le langage ECMAScript, vous devriez prendre quelques instants 

pour en faire un survol. 

Les implémentations ECMAScript supportent bien l’API DOM en général. La documentation 

de l’API DOM pour l’implémentation de ECMAScript de Firefox se trouve à 

l’adresse http://developer.mozilla.org/en/docs/Gecko_DOM_Reference. La principale 

différence entre DOM en ECMAScript et DOM en Java est que certaines méthodes en 

Java deviennent des attributs en ECMAScript (getNodeValue() devient nodeValue). 

ECMAScript peut donc lire et traiter des documents XML avec l’API DOM. En particulier, 

si ECMAScript est utilisé au sein d’une page XHTML, le script peut modifier la 

page dynamiquement en utilisant l’API DOM. La principale différence entre l’utilisation 

de DOM en Java et ECMAScript est qu’à l’exception des méthodes getAttribute, 

setAttribute, getAttributeNS, setAttributeNS, getAttributeNode, setAttributeNode, getAttributeNodeNS, 

setAttributeNodeNS, getElementsByTagName et getElementById, 

toutes les méthodes dont le nom commence par « get » ou « set » sont remplacées par un 

attribut de l’objet (ou « property » en anglais). Au lieu d’écrire « e.getChildNodes(); », 

on écrit « e.childNodes; », au lieu d’écrire « e.setNodeValue("texte"); », on écrit 

« e.nodeValue="texte"; », et ainsi de suite. 

Par exemple, le script suivant va ajouter du texte lorsque la souris passera sur l’élément 

ayant un attribut « id=’javatest’ ».. 

monele=document.getElementById(’javatest’); 

monele.childNodes.item(0).nodeValue+=’ (passage de souris) ’; 

CC BY-NC-SA


4.4.15 Asynchronous JavaScript And XML (AJAX) 

Normalement, sur un site web, pour aller chercher de l’information supplémentaire sur 

le serveur, tel que la description d’un produit ou l’horaire d’un film, il faut charger une 

nouvelle page web. Cependant, si l’information en question est disponible au format 

XML, un script ECMAScript peut la récupérer sans forcer le chargement d’une nouvelle 

page ce qui donne l’impression à l’utilisateur que l’application web est rapide, car 

il ne voit pas de chargement de pages. Le fait de pouvoir charger un fichier XML du 

serveur d’origine à partir d’un script ECMAScript constitue l’essentiel d’une technique 

appelée Asynchronous JavaScript And XML (AJAX) (JavaScript asynchrone et XML). 

Notons qu’à cause du modèle de sécurité ECMAScript, le fichier XML doit être sur le 

même serveur et être du même nom de domaine que la page HTML. 

Vous avez sans doute déjà utilisé une application AJAX. Les sites de courriel en ligne 

comme Google Mail l’utilisent presque tous pour charger le contenu d’un message sans 

forcer le chargement d’une nouvelle page. 

Si vous connaissez l’API DOM, la programmation d’une application AJAX n’est pas 

bien difficile. Il vous suffit d’apprendre un peu de ECMAScript. La classe XMLHttpRequest 

rend AJAX facile parce qu’elle permet d’aller chercher un fichier XML sur 

le serveur en quelques lignes de code. Voici un exemple simple de page web comportant 

un script ECMAScript et chargeant du contenu XML, en l’occurence, deux des 

pages web du cours: 

 

 

 

Exemple AJAX 

 

/* Cette fonction va chercher un document XML sur 

le serveur et appelle la fonction afficherTitre lorsque 

c’est fait! */ 

function chargeDocument(URI) { 

xmlhttp = new XMLHttpRequest(); 

xmlhttp.open("GET", URI,true); 

xmlhttp.onreadystatechange=function() { 

if (xmlhttp.readyState==4) { 

afficheTitre(xmlhttp.responseXML); 

} 

} 

xmlhttp.send(null); 

} 

/* Cette fonction est appelée lorsque le document XML est 

chargé */ 

CC BY-NC-SA


function afficheTitre(doc) { 

// on récupère le contenu de l’unique élément titre 

titreele = doc.getElementsByTagName("title").item(0); 

if(titreele.firstChild != null) 

titre=titreele.nodeValue; 

else 

titre = ""; 

// on ajoute un élément au document courant 

// "document" est le document XHTML, à ne pas confondre avec "doc" 

elementp = document.createElement("p"); 

elementp.appendChild(document.createTextNode(titre)); 

body = document.getElementsByTagName("body").item(0); 

body.appendChild(elementp); 

} 

 

 

 

Vous pouvez cliquer sur les liens suivants plus d’une fois. 

À chaque fois, votre navigateur charge un document XHTML et en 

affiche le titre. 

 

 

Récupère et affiche 

le titre du document domtutoriel.xhtml. 

 


le titre du document travail5.xhtml. 

 

 

 

Le code ECMAScript n’est pas très long comme vous pouvez le constater. L’attribut 

readyState de l’objet xmlhttp nous permet de déterminer quand le document XML a 

été chargé (xmlhttp.readyState==4). La propriété onreadystatechange est quant à elle 

appelée chaque fois que l’objet de type XMLHttpRequest change d’état. Lorsque le 

document XML est chargé, on peut donc appeler une fonction qui manipule le contenu 

de la page web (fonction afficheTitre). 

Voici un exemple similaire, mais qui récupère, cette fois-ci, le fichier RSS du journal 

le Devoir et en affiche les principales manchettes (le fichier RSS est une représentation 

en XML du contenu du journal). Il faut au préalable charger le fichier ledevoir.xml et le 

déposer dans le même répertoire que le fichier XHTML contenant le script AJAX, sur 

votre disque.Le fil de nouvelles du devoir se trouve normalement à l’adresse « http:// 

www.ledevoir.com/rss/ledevoir.xml ». 

CC BY-NC-SA


 

 

 

Exemple plus avancé en AJAX 

 


le serveur et appelle la fonction afficherTitres lorsque 



try { 





afficheTitres(xmlhttp.responseXML); 

} 

} 


} catch(o) {alert(o);} 

} 

/* Cette fonction est appelé lorsque le document XML est 

chargé */ 

function afficheTitres(doc) { 

titres = doc.getElementsByTagName("title"); 

elementol = document.createElement("ol"); 

var longueur = titres.length; 

for ( k = 0; k < longueur ; ++k) { 

elementli = document.createElement("li"); 

elementli.appendChild( 

document.createTextNode( 

titres[k].firstChild.nodeValue 

) 

); 

elementol.appendChild(elementli); 

} 

body = document.getElementsByTagName("body").item(0); 

body.appendChild(elementol); 

} 

 

 

 

 

CC BY-NC-SA


Récupère 

et affiche les nouvelles du devoir. 

 

 

 

Finalement, si on souhaite insérer non pas seulement du texte, mais des éléments provenant 

d’un autre document, on peut obtenir ce résultat avec la fonction importNode : 

 

 

 

Exemple AJAX avec importNode 

 


le serveur et appelle la fonction afficheListe lorsque 







afficheListe(xmlhttp.responseXML); 

} 

} 


} 

/* Cette fonction est appelé lorsque le document XML est 

chargé */ 

function afficheListe(doc) { 

ule = doc.getElementsByTagName("ul").item(0); 

// on récupère l’élément ul avec tout son contenu: 

body = document.getElementsByTagName("body").item(0) 

body.appendChild(document.importNode(ule,true)); 

} 

 

 

 

Vous pouvez cliquer sur les liens suivants plus d’une fois. 

À chaque fois, votre navigateur charge un document XHTML et en 

affiche une partie du contenu. 

 

CC BY-NC-SA



une liste du document domtutoriel.xhtml. 


une liste du document travail5.xhtml. 

 

 

 

La classe XMLHttpRequest fait l’objet d’une spécification du W3C. La construction 

d’un objet XMLHttpRequest est simple (xmlhttp = new XMLHttpRequest();) et généralement 

suivie de l’appel xmlhttp.open qui prend de 2 à 5 paramètres dont la méthode, 

l’URL, une valeur booléenne stipulant si l’appel est synchrone ou asynchrone, un nom 

d’utilisateur et un mot de passe. Les deux derniers paramètres sont utilisés si la ressource 

est protégée par mot de passe. On utilise généralement des appels asynchrone, 

pour éviter que le navigateur ne fige en attendant la réponse du serveur. La méthode est 

une des méthodes définie par le protocole HTTP (RFC 2616) dont GET, PUT, POST, 

et DELETE. 

On utilise le plus souvent AJAX avec des requêtes GET. Comme les requêtes 

GET ne nécessitent pas la transmission d’un document, on termine la requête avec 

« xmlhttp.send(null); ». Puisque la requête est asynchrone (le plus souvent) on doit 

définir une fonction qui sera appelée lorsque la réponse arrivera du serveur (onreadystatechange). 

Si la réponse du serveur est un fichier XML, on peut le récupérer avec 

l’attribut « responseXML ». Le document responseXML s’utilise comme tout document 

DOM. On peut aussi manipuler le document XHTML qui a fait l’appel AJAX 

avec l’API DOM. 

En somme, si on connaît bien l’API DOM, et si on connaît un peu d’ECMAScript, 

il est facile de développer des applications AJAX si on cible un navigateur comme 

Firefox. Par contre, les navigateurs diffèrent souvent beaucoup les uns des autres et, en 

particulier, Internet Explorer ne respecte pas les recommandations du W3C ce qui rend 

le développement plus difficile. 

Voici quelques sites qui utilisent AJAX : 

– http://www.objectgraph.com/dictionary/ 

– http://www.google.com/webhpcomplete=1&hl=en 

– http://maps.google.com/ 

Le site mozilla.org a plusieurs articles sur AJAX (en anglais). Depuis mai 2006, 

Google rend disponible gratuitement son Google Web Toolkit qui permet de construire 

des applications AJAX en Java fonctionnant avec tous les principaux navigateurs. Il 

existe d’autres librairies AJAX telles que Dojo, Rico, et la Yahoo! User Interface 

Library. Une librairie particulièrement intéressante est la librairie Prototype (http:// 

www.prototypejs.org/) qui est constituée d’un seul fichier ECMAScript. 

CC BY-NC-SA

DOM 327 

Malheureusement, le traitement d’un document XML en ECMAScript est parfois inutilement 

lourd. Pour cette raison, on remplace souvent le XML par du JavaScript Object 

Notation (JSON) ou par du HTML. 

4.4.16 DOM et autres langages 

L’API DOM est supportée en C++ (voir Xerces-C), en Python (paquetage xml.dom), 

en Perl (voir Xerces-P), en ECMAScript, etc. C’est d’ailleurs la principale force de 

cette API : peu importe le contexte, il y a fort à parier que vous aurez accès à l’API 

DOM. Ce n’est sans doute pas la meilleure API possible, mais son ubiquité fait en sorte 

qu’il vaut la peine d’apprendre à la connaître. 


Dans ce tutoriel, nous avons appris à lire et à écrire du XML à partir du Java. Nous 

avons aussi appris à mieux comprendre le modèle DOM et, en particulier, sa structure 

en arbre. Vous devriez maintenant être en mesure de commencer à créer des applications 

Java, de filtrer, fusionner et modifier du XML. 


– Elliotte Rusty Harold, Processing XML with Java: A Guide to SAX, DOM, JDOM, 

JAXP, and TrAX, Addison-Wesley Professional, 2002, 1120 pages. 

– Frank W. Zammetti, Practical Ajax Projects with Java Technology, Apress, 2006, 

504 pages. 

– Brett McLaughlin, Head Rush AJAX, O’Reilly Media, 2006, 413 pages. 

4.5 DOM 


Comprendre l’approche DOM. 


Lisez le texte qui suit, puis répondez au questionnaire d’autoévaluation en vous référant 

au tutoriel sur DOM que vous venez d’utiliser. 

On peut définir DOM comme un ensemble d’API (Application Program Interface) : 

un ensemble de fonctions et d’objets que l’on peut utiliser en Java (ou autres langages 

CC BY-NC-SA


similaires) pour manipuler le XML selon un modèle en arbre. Dans ce cours, nous 

allons nous pencher plus particulièrement sur l’incarnation Java de DOM. 

Note.- Le terme DOM désigne aussi un type de modèle en arbre représentant le XML. 

Il y a donc deux significations au terme « DOM » : un ensemble d’API utilisant un 

modèle en arbre ou un certain modèle en arbre. 

Un des avantages de DOM est qu’il est indépendant du langage ou de la plate-forme. 

Ainsi, si vous connaissez DOM, vous pourrez l’utiliser dans plusieurs contextes différents. 

Ce qui est peut-être le plus important, c’est que les concepts propres à DOM se 

retrouvent dans d’autres API pour traiter le XML, qu’elles soient produites par Microsoft, 

Sun Microsystems ou d’autres auteurs. 

Dans une API DOM, tous les éléments sont immédiatement accessibles : on lit le fichier 

une fois et il est ensuite totalement en mémoire. La contrepartie de cet avantage est que 

DOM utilise beaucoup de mémoire parce qu’il doit charger la totalité des fichiers XML. 

Notez toutefois que, dans le contexte DOM, il serait possible, en principe, de ne pas 

tout charger en mémoire. 

Comme nous l’avons vu, l’API DOM permet de créer des documents XML, de 

naviguer dans des documents XML, d’ajouter, de modifier ou d’éliminer des éléments 

XML. 


1. Si j’ai une application DOM et que je charge 100 fichiers XML faisant un Mo 

chacun, je m’attends que mon programme utilise au moins 100 Mo. 


(a) Vrai 

(b) Faux 

2. Un arbre DOM est constitué d’éléments contenant d’autres éléments. Choisissez 


(a) Vrai 

(b) Faux 

3. Dans un arbre DOM, que trouve-t-on à la racine Choisissez la bonne réponse 


(a) L’élément-racine du document XML. 

(b) Il n’y a pas de racine unique. 

(c) Le document lui-même contenant, parmi d’autres choses, l’élément-racine 

du document XML. 

4. Parmi les types de nœuds DOM suivants, quels sont ceux qui ne peuvent pas 

avoir d’enfants Choisissez toutes les réponses qui s’appliquent. 

CC BY-NC-SA

DOM 329 

(a) DocumentType (modèle pour une déclaration de type de document) 

(b) Element (modèle pour un élément) 

(c) Comment (modèle pour un commentaire) 

(d) Document (modèle pour le document lui-même) 

(e) Text (modèle pour du texte contenu dans un élément) 

5. Un arbre DOM donne accès à tout le contenu en information pertinente d’un 

document XML. Choisissez la bonne réponse parmi les choix suivants. 

(a) Vrai 

(b) Faux 

6. Un arbre DOM correspond à un document XML unique. Choisissez la bonne 


(a) Vrai 

(b) Faux 



(b) L’affirmation est correcte : DOM utilise beaucoup de mémoire. 

2. (a) L’affirmation est techniquement incorrecte. C’est un arbre de nœuds et les 

nœuds ne sont pas tous des éléments. Par exemple, une instruction de traitement 

ou une déclaration de type de document est un nœud. 

(b) (Bonne réponse) Effectivement. XML est une structure d’arbre en éléments, 

mais DOM utilise une structure plus générale d’arbre de nœuds, 

où les nœuds n’ont pas à être des éléments. En général, par contre, seuls les 

éléments (et le document) peuvent avoir des descendants. 

3. (a) Non. Si c’était le cas, on ne pourrait avoir accès à la déclaration de type de 

document, par exemple. 

(b) Ce ne serait alors pas un arbre. 


4. (a) (Bonne réponse) La déclaration de type de document n’a pas d’enfants; elle 

ne peut pas contenir, par exemple, des éléments. 

(b) Un élément peut avoir des enfants. 

(c) (Bonne réponse) Les commentaires ne peuvent pas avoir d’enfants. 

(d) Le document peut avoir des enfants. 

(e) (Bonne réponse) Du texte ne peut pas avoir d’enfants. 

5. (a) (Bonne réponse) DOM est complet : vous pouvez obtenir tout le contenu 

en information du document XML. Dans un logiciel normal, il ne devrait 

jamais être nécessaire d’utiliser autre chose que DOM pour extraire l’information 

contenue dans un document XML. 

CC BY-NC-SA


(b) L’affirmation était correcte. 

6. (a) Il peut y avoir plusieurs documents disposés différemment, mais contenant 

la même information. 

(b) (Bonne réponse) C’est juste. Deux librairies DOM pourraient, avec le 

même arbre, générer des documents XML différents. 



Le travail noté 5, une activité de programmation Java, compte pour 15 % de la note 

globale du cours. 

Il contribue à l’atteinte des objectifs suivants : 


– Appliquer la méthodologie orientée objet pour la consommation, la fusion et le filtrage 


Le travail comporte cinq exercices, valant respectivement 3, 4, 4, 2 et 2 points, pour un 

total de 15 points. 

4.6.2 Consignes générales 

1. Utilisez les noms des fichiers spécifiés dans chaque exercice. 

2. Vous n’avez droit qu’à un seul fichier « .java » par exercice et il ne doit pas 

contenir plus de 500 lignes de code. Tous les problèmes peuvent être résolus en 

moins de 100 lignes! Rappelons qu’une « ligne » de code comprend un maximum 

de 80 caractères. 

3. Chaque fichier doit débuter par un commentaire donnant le sigle du cours et votre 

nom comme ceci : 

/** 

* INF 6450 - Travail noté 5 - Votre nom, fait avec SDK 1.5.0_06 

*/ 

4. Vous devriez pouvoir accéder à la version de votre SDK, en tapant « javac - 

version » ou « java -version » dans une ligne de commande. 

5. Ne traitez pas les cas d’exception, comme les fichiers qui n’existent pas ou ne 

peuvent être ouverts. Par contre, votre code doit produire un résultat correct dans 

des conditions normales. Par exemple, si on vous demande de produire du XML, 

il doit s’agir de XML bien formé. Si on vous demande de lire du XML, vous 

devez pouvoir lire tout XML qui se conforme aux spécifications décrites dans 

l’exercice. Vous devez utiliser l’API DOM. 

CC BY-NC-SA


6. Il est impératif que vos fichiers compilent avec le SDK (le plus récent), sans 

utiliser de librairies particulières. Un fichier Java qui ne compile pas ne sera 

pas noté. 

7. Lorsque vous aurez terminé les exercices, vous devez transmettre à votre personne 

tutrice, par courriel, l’ensemble des fichiers avec l’extension Java comme 

fichiers attachés. Vous devez aussi remettre un fichier XML ainsi qu’un document 

(Word 97/2000/XP, ODF, PDF, RTF ou en format texte) clairement identifié 

à votre nom contenant l’analyse demandée à la première question du travail. 

L’objet de votre courriel doit commencer par « [INF6450][TRAVAIL5] »; 

dans le message, indiquez votre nom, votre numéro d’étudiant (8 chiffres), 

la date de remise de votre travail et le nom de votre personne tutrice, ainsi 

que les mentions « Travail noté 5 » et « INF 6450 ». Ne transmettez pas une 

archive compressée (zip ou autre). Il s’agit d’un travail personnel et vous ne 

devez pas partager vos solutions. 


Supposons une liste de transactions avec un attribut « montant » pour chaque client, 

comme dans le document XML suivant : 

 

 

 

 

Quelle est la dernière marque 

 

 

 

 

 

Où puis-je trouver le modèle 2002 

 

 

 

Supposons que le fichier se nomme « transactions.xml ». 

Nous ne savons pas combien de transactions il peut y avoir par client; nous ne savons 

pas combien de clients nous avons; de plus, nous ne connaissons pas les noms 

des clients d’avance. Nous supposons que l’élément-racine est toujours « liste »; que 

tous les éléments « transaction » ont un attribut « montant »; que tous les éléments 

« transaction » sont dans des éléments « client »; que les éléments « client » sont tous 

dans l’élément-racine et ont tous un attribut « nom ». Nous supposons également qu’il 

n’y aura pas deux attributs « nom » avec la même valeur (même nom). Enfin, nous 

CC BY-NC-SA


supposons que toutes les valeurs d’attribut de « montant » sont des entiers (« int » en 

Java). 

Écrivez un programme qui calcule la somme des valeurs de l’attribut « montant » pour 

chaque client (seuls les attributs « montant » des éléments « transaction »). Nous supposons 

qu’il s’agit de nombres entiers, des dollars par exemple. Le code source de votre 

programme sera dans un fichier nommé « Transactions.java ». 

Ainsi, la commande « java Transactions transactions.xml » devra donner : 

Nom du client: Jean Charles 

Somme: 1700 

Nom du client: Pierre Élisabeth 

Somme: 3400 

Comparez la solution que vous obtenez en utilisant DOM avec ce qui est possible 

de faire avec XSLT, en fonction du temps de développement. Donnez au moins un 

avantage de l’approche DOM sur l’approche XSLT et un avantage de l’approche XSLT 

sur DOM. Vous devez remettre une solution XSLT sous la forme d’un document XML. 

Vous pouvez mettre des commentaires dans votre code Java, mais la comparaison entre 

DOM et XSLT doit être faite dans un document à part. 


Avec XSLT, nous pouvons combiner plusieurs documents en utilisant la fonction « document 

» qui permet de charger plusieurs documents XML. Mais que se passe-t-il 

lorsque nous devons combiner plusieurs documents, dont certains ne sont pas en XML 

À ce moment, l’utilisation d’un langage comme Java et de DOM peut être très avantageuse. 

Supposons qu’un serveur enregistre les achats effectués sur le site, dans un fichier texte, 

en plaçant chaque achat sur une ligne avec des informations séparées par des virgules. 

Le fichier se nomme « achats.txt » : 

Jean Charles, 3214324565, 321, 2 

Yvan Richard, 5435435545, 321, 1 

Yvette Gagnon, 4324324243, 1, 12 

Sur chaque ligne, se trouvent le nom du client, son numéro de carte de crédit, le code 

du produit acheté et la quantité achetée. Nous supposons que le serveur est un logiciel 

commercial et qu’il n’est pas possible de le modifier pour obtenir le format des données 

en XML. 

Par ailleurs, nous avons un document XML contenant notre inventaire; le fichier se 

nomme « inventaire.xml ». Le voici : 

 

 

 

CC BY-NC-SA


 

 

 

Écrivez un programme qui met à jour l’inventaire en tenant compte des achats de la 

journée, contenus dans le fichier « achats.txt ». Votre code source devra se trouver 

dans le fichier « Inventaire.java » et la commande « java Inventaire achats.txt inventaire.xml 

» va modifier le fichier « inventaire » pour y soustraire les produits achetés 

ce qui, dans le cas qui nous concerne, donnera un fichier « inventaire.xml » ayant le 


 

 

 

 

 

 

Nous pouvons supposer que le fichier « inventaire.xml » ne contient qu’un seul élément 

« produit » pour chaque valeur d’attribut « code ». Nous pouvons aussi supposer qu’aucun 

code invalide n’apparaît dans le fichier « achats.txt ». Par contre, nous ne savons 

pas combien de produits nous avons et combien d’achats il y aura. Évidemment, il est 

possible d’avoir un nombre négatif de produits dans notre inventaire. 

Indice.- Il est parfaitement possible d’écrire un tel programme en moins de 50 lignes. 


Il arrive que les données initiales ne soient pas en XML. Dans cet exercice, nous vous 

demandons de concevoir une calculatrice qui affiche ses résultats en XML (MathML 

pour être plus précis). 

Tout d’abord, pour vous convaincre qu’on peut écrire des équations en XML, transcrivez 

le contenu XML suivant dans un fichier nommé « math.xml » : 

 

 

 

1 

+ 

2 

= 

3.0 

 

 

Si vous ouvrez ce ficher dans Mozilla Firefox, vous devriez voir s’afficher le texte « 1 + 

2 = 3 ». Cela signifie que Firefox reconnaît la syntaxe MathML. Vous pouvez constater 

CC BY-NC-SA


que cette syntaxe n’est pas très complexe, du moins pour des exemples simples. Sachez 

que l’espace de noms de MathML est « http://www.w3.org/1998/Math/MathML ». Il 

faut utiliser comme élément-racine un élément « math », lui-même contenant un élément 

« mrow ». L’élément « mrow » pourra contenir un succession d’éléments « mn » 

(pour les nombres) et d’éléments « mo » (pour les opérateurs, comme « + », « < », 

« > », « - »). Si le résultat attendu est du texte, comme « vrai » ou « faux », il faut 

utiliser l’élément « mrow » contenant un élément « mtext » qui lui contient le texte, par 

exemple vrai). 

Vous devez créer un programme dont le code source se trouvera dans un fichier nommé 

« Calculatrice.java Votre programme doit utiliser l’API DOM. La calculatrice ne 

saura faire que 4 opérations : addition, soustraction et deux opérations de comparaison 

(< et >) dont la réponse est « vrai » ou « faux ». Ainsi, toutes les opérations se retrouvent 

dans la forme : 1 + 2, 1 - 2, 1 < 2 et 2 > 1. 

Par exemple, la commande « java Calculatrice 1.5 "



Il est parfois pénible d’utiliser l’interface DOM quand on cherche une seule information 

précise. Écrivez un programme Java qui permet d’extraire le prix correspondant à 

l’item ayant le code de produit 321 dans un fichier XML ayant la forme suivante en 

utilisant une expression XPath. 

 

 

 

 

 

 


En utilisant AJAX, on peut rendre une page web dynamique. Malheureusement, pour 

des raisons de sécurité, un script dans une page web ne peut charger un fichier qui se 

trouve dans un domaine autre que celui d’origine. On vous demande donc de déposer 

le fichier ledevoir.xml (il faut suivre l’hyperlien) sur votre machine et de créer une 

page web AJAX capable de charger le fichier XML en question et d’afficher tant le 

titre des nouvelles que leur description complète. Attention, il ne faut récupérer que le 

contenu des éléments au sein des éléments item. Vous pouvez supposer que les titres et 

descriptions ne contiennent que du texte, sans éléments HTML. Si vous préférez, vous 

pouvez aussi utiliser le dernier fil de nouvelle du devoir, disponible à l’adresse « http:/ 

/www.ledevoir.com/rss/ledevoir.xml ». 

Si les descriptions contiennent du texte sous la forme &lta href="...">, il n’est pas 

nécessaire de les afficher sous la forme d’hyperliens. 

Certains étudiants trouvent utile d’utiliser la syntaxe « try catch(e) » de l’ECMAScript 

(qui fonctionne comme en Java) pour traiter les erreurs. Cependant, cette syntaxe n’est 

pas nécessaire. 

CC BY-NC-SA

Module 5 : Resource 

Description Framework (RDF) 

5.1 Aperçu 


Les graphes annotés sont un outil puissant de représentation des connaissances; en 

XML, on utilise certains graphes dirigés et annotés. Le module 5 porte sur le « Resource 

Description Framework (RDF) », une forme de représentation des connaissances; 

le modèle RDF est un modèle de graphe pouvant s’écrire en XML. 

Bien qu’il s’agisse d’une norme qui fait appel à des concepts abstraits, dans la pratique, 

le RDF est très utilisé. Il suffit de faire une recherche sur le web sur des sujets comme 

« Dublin Core, Creative Commons, FOAF, RSS 1.0 » pour constater à quel point le 

RDF est présent. Le résultat d’une recherche sur Google pour « Dublin Core » donne 

1,2 million de pages; la recherche sur « Creative Commons » annonce 5,5 millions de 

pages et celle sur « FOAF » donne 1,5 million de pages. De plus, le RDF est intimement 

lié au XML, car très souvent des données RDF sont écrites en format XML. 

L’objectif spécifique du module est : 


Une activité, le travail noté 6, nous permettra d’évaluer votre atteinte de cet objectif. 

Avant d’entreprendre votre démarche, lisez le texte qui suit. 

5.1.2 Représentation des connaissances et graphes 

Le cours porte sur le XML en tant qu’outil pour la gestion des connaissances. Nous 

avons vu, dans les modules précédents, le rôle que peut jouer le XML comme outil 

dans la gestion des données, qui sont une forme de connaissances de premier niveau : le 

337


XML rend plus facile l’échange et la transformation des données. De plus, notamment 

dans le module 2, nous avons vu que le XML permet le marquage « sémantique » 

des informations; le XML s’impose donc naturellement comme outil de gestion des 

connaissances. En effet, prenons cet exemple de marquage sémantique : 

 

 

Jean 

3 février 1971 

 

Ce document XML contient non seulement l’information souhaitée, mais en plus, à un 

niveau élémentaire, il nous permet de comprendre le sens de cette information, grâce 

aux noms des balises. 

Cependant, utiliser le nom des balises pour représenter les connaissances n’est pas 

toujours très pratique. Supposons que nous ayons deux documents XML semblables à 

celui de l’exemple précédent. Comment pouvons-nous représenter le fait que les deux 

personnes sont amies 

Une façon plus naturelle de représenter les connaissances est d’utiliser des graphes. 

Un graphe est un ensemble de nœuds liés par des relations d’un nœud à un autre. Par 

exemple, l’ensemble des pages web forme un graphe avec la relation « contient un 

lien vers ». On dit que le graphe est « dirigé » si les relations sont à sens unique. 

Le web est un exemple de graphe dirigé : une page web peut avoir un lien vers une 

autre page web, qui elle-même ne contient pas un lien de retour vers la page d’origine. 

On dit qu’un graphe est « annoté » si les relations entre deux nœuds peuvent être de 

différentes natures. Par exemple, une communauté d’humains forme un graphe dirigé 

avec les relations « est ami avec » et « est parent avec ». Supposons que les relations 

« est ami avec » et « est parent avec » soient réflexives, alors le graphe d’humains 

est annoté, mais pas dirigé. Par contre, si nous acceptons qu’une personne puisse être 

l’ami de quelqu’un sans que cette personne soit son ami, alors le graphe d’humains 

sera annoté et dirigé. 

Pour des raisons pratiques, nous représentons les graphes avec des tableaux en trois 

colonnes. 


Il faut avoir terminé le premier module avant de s’attaquer au module 5; en outre, 

il sera très utile d’avoir commencé les modules 2, 3 et 4 afin d’avoir suffisamment 

d’expérience avec le XML. 

Nous vous suggérons d’étudier, dans l’ordre, les deux textes proposés et de répondre 

aux questionnaires d’autoévaluation les accompagnant : 

– Introduction au RDF; 

– Le RDF par l’exemple, Dublin Core, Creative Commons, FOAF, RSS/Atom. 

CC BY-NC-SA

Introduction au RDF 339 

Le module se termine par le travail noté 6, qui prend la forme d’une activité de synthèse. 

Il est recommandé de répondre d’abord aux deux questionnaires d’autoévaluation avant 

de réaliser ce travail. 

5.1.4 Préparation à l’examen 

Une fois les activités du module terminées, vous devrez vous préparer à l’examen. Pour 

vérifier si vous êtes prêt, vous pouvez télécharger l’examen factice (PDF, 79 Ko). Si 

vous pouvez faire cet examen sans problème, tout va bien. Pour vérifier vos réponses, 

consultez le corrigé (PDF, 195 Ko). 

5.1.5 Évaluation du cours 

Lorsque vous aurez terminé le cours, répondez au questionnaire d’évaluation du cours 

(Microsoft Word, 163 Ko) , afin de nous aider à l’améliorer. Votre opinion et vos commentaires 

sont très importants pour nous. Nous vous remercions à l’avance de votre 

collaboration. 

5.2 Introduction au RDF 

5.2.1 Introduction 

Le Resource Description Framework (RDF) est un langage pour les métadonnées sur 

le web, c’est-à-dire un langage pour énoncer ce que l’on sait sur quelque chose ou 

quelqu’un. Par exemple, le RDF est idéal pour indiquer qui est l’auteur d’un document 

ou quel est le titre du document. De plus, le langage RDF est prévu pour être à la fois 

simple (mais tout est relatif), suffisamment puissant pour « tout » décrire, et facilement 

utilisable par des logiciels. Dans le deuxième texte que nous proposons, Le RDF par 

l’exemple, nous verrons quelques applications intéressantes. Pour l’instant, nous ne 

présentons dans ce texte que les concepts de base. 


Le RDF demeure relativement peu utilisé dans des applications complexes, même s’il 

s’agit d’une idée simple et élégante. Une des raisons qui contribue sans aucun doute à 

ce manque de popularité du RDF, est la syntaxe RDF/XML qui n’est pas très jolie. 

CC BY-NC-SA



Le RDF a été normalisé en 1999 (par une recommandation W3C) et est un effort commun 

de plusieurs experts. Le RDF se veut suffisamment riche pour représenter de façon 

formelle la connaissance tout en étant simple à utiliser. Une des prémisses du format 

RDF est que tout peut être énoncé en utilisant des triplets : sujet, verbe et objet. Notez 

que certains auteurs utiliseront le terme « prédicat » au lieu du terme « verbe ». Par 

exemple, pour décrire « Jean », nous dirons que « Jean est un garçon » et nous décomposerons 

ainsi cette affirmation : , ou l’afficherons dans un 

tableau : 

Sujet Verbe Objet 

Jean est garçon 

Nous ne faisons pas de la grammaire, mais bien de la représentation : le verbe n’a pas 

à être un verbe de la langue française ou anglaise. L’important est que le verbe soit un 

lien, une relation, entre une première chose (sujet) et une seconde (objet). Par exemple, 

si nous voulons affirmer que le titre de la page web « http://www.daniel-lemire.com/ » 

est « Daniel Lemire’s blog », nous pouvons le faire à l’aide du tableau suivant : 


http://www.daniellemire.com/ 

titre 

Daniel Lemire’s blog 

Ces exemples de représentation ne sont pas encore des exemples de données « RDF », 

car en RDF, le verbe doit être un URI. Le RDF, tout comme le XML, est fait pour 

être traité par des machines et les machines sont bêtes. Elles ne savent pas ce que 

signifie le mot « titre » dans le tableau précédent. Est-ce un titre à la Bourse, le titre 

d’une fonction (comme docteur) ou le titre d’une page Pour régler ce problème, il 

faut utiliser des URI (Uniform Resource Identifier), c’est-à-dire des adresses fictives 

qui identifient une ressource Internet. 

Un URI contient un protocole (http, mailto, ftp, etc.), un domaine comme « fichiers.com 

» et un chemin comme « /mesfichiers/index.html ». Dans ce cours, nous 

adoptons la norme RFC2396 et nous permettons que les URI comportent le symbole 

du dièse ( # ), comme « ftp://fichiers.com#maman » : tout ce qui apparaît après ce symbole 

forme le « fragment ». Notons que les accents ne peuvent pas être utilisés dans 

un URI; ainsi, « http://école.com » n’est pas un URI valable. Un protocole particulier, 

« urn », est parfois utilisé dans les URI. Par exemple, pour identifier un livre par son 

code ISBN, nous pouvons utiliser l’URI « urn:ISBN:0-123-12345-1 ». La casse est significative 

dans un URI sauf pour le nom du protocole (HTTP ou http) et le nom du 

domaine (xerox.com ou XEROX.COM). 

Toutes les URL (Uniform Resource Locator) utilisées sur le web, comme 

« http://www.google.com », « mailto:bill@microsoft.com », « ftp://fichiers.com », 

ainsi que d’autres adresses ayant la même syntaxe, mais qui ne pointent pas nécessairement 

vers une ressource Internet existante, sont des exemples d’URI. Ainsi, si l’on vous 

donne l’URI « http://www.mydomain.com/daniel », il n’est pas certain qu’une page 

CC BY-NC-SA


web se trouve à cette adresse. Le seul but des URI est d’identifier des ressources. Le mot 

« ressource » a un sens très, très large : tout peut être considéré comme une ressource. 

Par exemple, pour identifier l’humoriste « Daniel Lemire », nous pouvons adopter 

l’URI « http://www.daniellemire.com/luimeme »; ce sera un bon choix si l’humoriste 

en question est propriétaire du nom de domaine (daniellemire.com) et compte le garder 

longtemps. Par ailleurs, on pourra utiliser l’URI « http://www.daniel-lemire.com/fr/ » 

pour identifier le professeur « Daniel Lemire » qui est responsable d’un cours portant 

sur le XML. Dans ce dernier exemple, l’URI est aussi un URL qui pointe vers la page 

personnelle du professeur. Nous voyons immédiatement l’avantage des URI : alors que 

l’ordinateur ne saura pas toujours faire la différence entre « Daniel Lemire » l’humoriste 

et « Daniel Lemire » le professeur, nous pourrons, en utilisant des URI, analyser 

automatiquement l’information, à la condition que tous utilisent le même URI pour 

représenter la même ressource. Pour distinguer les individus, nous pourrions utiliser 

leur numéro d’assurance sociale... Mais comme le concept de ressource est général, il 

faut aussi pouvoir distinguer les différentes significations que peuvent prendre le mot 

« titre », et ainsi de suite. La langue française (ou anglaise) permet à un mot d’avoir 

plusieurs sens, alors que chaque URI représente un concept et un concept seulement. 

Supposons maintenant que nous voulions décrire l’affirmation suivante en RDF : 

« Il y a une personne appelée Daniel Lemire dont l’adresse de courriel est dlemire@teluq.uqam.ca 

et qui est professeur. » Cette phrase peut être très difficile à 

analyser par un ordinateur. Commençons par la décomposer en affirmations simples : 

sujet/verbe/objet. D’abord, pour qu’il n’y ait pas de confusion, nous allons identifier 

l’individu s’appelant Daniel Lemire par l’URI « http://www.daniel-lemire.com/fr/ ». 

– http://www.daniel-lemire.com/fr/ est une personne. 

– http://www.daniel-lemire.com/fr/ s’appelle Daniel Lemire. 

– http://www.daniel-lemire.com/fr/ peut être joint par courriel à dlemire@teluq.uqam.ca. 

– http://www.daniel-lemire.com/fr/ a le titre de professeur. 

Rappelons ici que tous les verbes et tous les sujets doivent être identifiés par des URI. 

En ce qui nous concerne, il n’y a qu’un seul sujet identifié par « http://www.daniellemire.com/fr/ 

». Il reste à trouver des URI pour les verbes et certains objets. Prenons 

d’abord la première affirmation : « http://www.daniel-lemire.com/fr/ est une personne 

». Le verbe « être », dans cette phrase, associe la classe « personne » (au même 

sens que dans la programmation orientée objet) à la ressource « http://www.daniellemire.com/fr/ 

». Nous pourrions inventer un URI ayant ce sens, mais il en existe déjà 

un : « http://www.w3.org/1999/02/22-rdf-syntax-ns#type ». Chaque fois que nous rencontrons 

cet URI, cela signifie qu’une ressource appartient à une certaine classe. Quant 

à l’objet « personne », il existe au moins un URI pour noter la classe « personne », 

soit « http://www.w3.org/2000/10/swap/pim/contact#Person ». Nous verrons que dans 

d’autres contextes, d’autres URI peuvent être utilisés avec un sens similaire. 

Finalement, l’affirmation « http://www.daniel-lemire.com/fr/ est une personne » peut 

s’écrire comme ceci : 

CC BY-NC-SA




http://www.w3.org/1999/ http://www.w3.org/ 

en/ 

02/22-rdf-syntax-ns#type 2000/ 10/swap/pim/ 

contact#Person 

Passons maintenant à la deuxième affirmation : « http://www.daniel-lemire.com/fr/ 

s’appelle Daniel Lemire ». Le verbe « s’appelle » peut être identifié par l’URI 

« http://www.w3.org/2000/10/swap/pim/contact#fullName ». Encore une fois, nous aurions 

pu inventer notre propre URI, en autant que nous utilisons toujours le même avec 

la même signification. L’objet, « Daniel Lemire », n’a pas de signification particulière 

et n’est qu’une chaîne de caractères; nous ne sommes donc pas tenus d’utiliser un URI. 

Cela n’est vrai que pour les objets : les sujets et les verbes doivent toujours être représentés 

par des URI en RDF. Nous obtenons le tableau suivant : 



en/ 

http://www.w3.org/ 

2000/ 10/swap/pim/ 

contact#fullName 

"Daniel Lemire" 

Nous notons les chaînes de caractères avec les guillemets : alors que 

« http://www.unuri.org » est un URI, « "http://www.unuri.org" » est une chaîne 

de caractères. 

Dans l’affirmation « http://www.daniel-lemire.com/fr/ peut être joint par 

courriel à dlemire@teluq.uqam.ca », nous pouvons remplacer le verbe par 

« http://www.w3.org/2000/10/swap/pim/contact#mailbox ». Quant à l’objet « dlemire@teluq.uqam.ca 

», c’est une adresse de courriel; afin qu’un ordinateur puisse 

comprendre qu’il s’agit d’une adresse de courriel et non d’une chaîne de caractères, 

nous utiliserons l’URL « mailto:dlemire@teluq.uqam.ca » pour le représenter. Nous 

avons donc le tableau suivant : 



en/ 


2000/ 10/swap/pim/ 

contact#mailbox 

L’affirmation « http://www.daniel-lemire.com/fr/ a le titre de professeur » se traite de 

la même manière, de telle sorte que nous obtenons finalement le tableau suivant : 


mailto:dlemire@teluq.uqam.ca 


en/ 


en/ 

http://www.w3.org/1999/ 

02/22-rdf-syntax-ns#type 


2000/ 10/swap/pim/ 



2000/ 10/swap/pim/ 



CC BY-NC-SA




http://www.w3.org/ mailto:dlemire@teluq.uqam.ca 

en/ 

2000/ 10/swap/pim/ 


en/ 



2000/ 10/swap/pim/ 

contact#personalTitle 

"Professeur" 

Précisons qu’en RDF, l’ordre des affirmations est sans importance. Ainsi, l’ordre des 

rangées dans le tableau est sans importance. 

Ce tableau est une description formelle de notre phrase d’origine « Il y a une personne 

appelée Daniel Lemire dont l’adresse de courriel est dlemire@teluq.uqam.ca et qui est 

professeur. »; cette description peut être traitée par un ordinateur. 

Comme nous le verrons plus loin, ce tableau RDF peut s’écrire en XML de la façon 

suivante : 

 

 

 

Daniel Lemire 

 

Professeur 

 

 

On peut aussi représenter graphiquement le tableau RDF : 

http://www.daniel-lemire.com/fr/ 

Type 

fullName 

mailbox 

personalTitle 

Person 

Daniel Lemire 

dlemire@teluq.uqam.ca 

Professeur 

Nous pouvons également spécifier dans quelle langue une chaîne de caractères est 

écrite; par exemple, le mot « professeur » n’a de sens qu’en français. Pour ce faire, 

nous utiliserons un attribut « xml:lang » ayant pour valeur un code ISO à deux caractères 

pour représenter la langue : « fr » pour français, « en » pour anglais, et ainsi de 

suite. Notre exemple modifié se lit comme suit : 

 

 

 

CC BY-NC-SA


Daniel Lemire 

 

Professeur 

 

 

Le choix de la langue ne constitue pas une nouvelle relation RDF, mais vient simplement 

annoter l’objet : dans un tableau sujet/verbe/objet, nous nous contenterons, par 

exemple, de remplacer « "Professeur" » par « "Professeur" (français) ». 

Nous pouvons résumer le RDF comme ceci : 

– Le RDF peut être utilisé pour représenter tout objet, tant un site web qu’un individu. 

– Le RDF peut être traité par une machine. 

– Le RDF est composé de triplets : sujet/verbe/objet. 

– Le sujet est toujours identifié par un URI; mais dans certains cas, on peut omettre 

l’URI et alors, un URI factice sera généré dynamiquement. 

– Le verbe est toujours identifié par un URI, sans aucune exception. 

– L’objet est soit un URI, soit une valeur explicite (une chaîne de caractères, par 

exemple). 

– Le RDF peut être représenté en XML. 

5.2.4 Le RDF en XML 

Avertissement.- Tous les contenus RDF ne peuvent être représentés en XML selon la 

méthode que nous venons de présenter. La grande majorité du contenu RDF peut l’être, 

mais il y a des exceptions. Pour éviter les problèmes, nous supposerons ici que l’URI du 

verbe prend la forme « http://www.domaine.com/blabla/bla#vvv ». En d’autres termes, 

l’URI du verbe contient le symbole du dièse ( # ) et le texte après ce symbole est un 

nom XML valable (pouvant être utilisé comme balise). 

Il existe plusieurs façons de représenter le RDF en XML, mais nous n’étudierons que 

l’approche préconisée par le W3C, qui est l’approche la plus courante. Par ailleurs, 

nous n’étudierons pas toute la syntaxe RDF/XML, mais seulement ce qui est nécessaire 

pour comprendre la majorité du RDF qui se trouve actuellement sur le web. 

En règle générale, les documents XML représentant du contenu RDF n’ont pas de 

DTD, mais utilisent les espaces de noms. Nous commençons habituellement un document 

par une déclaration XML qui sera soit « », soit « » pour permettre l’utilisation des accents 

français. Ensuite, viendra toujours l’élément RDF comme élément-racine. Ainsi, un 

des documents XML les plus simples possibles représentant du contenu RDF est : 

 

 

 

CC BY-NC-SA


Observez l’utilisation de l’espace de noms identifié par l’URI 

« http://www.w3.org/1999/02/22-rdf-syntax-ns# ». Le fait de noter l’espace de 

noms par les trois lettres « rdf » est sans conséquence et nous pourrions aussi écrire : 

 

 

 

L’important, c’est que l’élément-racine RDF soit dans l’espace de nom 

« http://www.w3.org/1999/02/22-rdf-syntax-ns# ». Supposons maintenant que 

nous voulions décrire l’affirmation RDF suivante : 



2000/ 10/swap/pim/ 


http://www.daniellemire.com/fr/ 


La première étape consiste à décomposer l’URI du verbe en 

deux parties : l’URI jusqu’au symbole « # » inclusivement, soit 

« http://www.w3.org/2000/10/swap/pim/contact# », et le reste du texte, soit « mailbox 

». La première partie devient un espace de noms, et la deuxième, appelée fragment, 

deviendra un nom d’élément. On utilise ensuite habituellement une balise « Description 

» dans l’espace de noms « http://www.w3.org/1999/02/22-rdf-syntax-ns# » avec 

le nom d’attribut « about » comme ceci : 

 

 

 

 

 

 

Dans cet exemple, le sujet est la valeur d’attribut de « about », soit « http://www.daniellemire.com/fr/ 

», le verbe est le nom de l’élément contenu dans l’élément 

« rdf:Description », ici « mailbox », auquel on ajoute en préfixe l’espace de 

noms auquel il appartient, soit « http://www.w3.org/2000/10/swap/pim/contact# ». 

L’URI de l’objet est la valeur de l’attribut « rdf:resource », soit 

« mailto:dlemire@teluq.uqam.ca ». 

Pour nous assurer de bien comprendre, voyons un autre exemple, quoique plus abstrait. 

Supposons que nous ayons le contenu RDF suivant : 


http://domaine.com/ 

page/ 

http://domaine.com#unverbe 

http://www.objet.com/ 

Nous pourrions utiliser la représentation XML suivante : 

CC BY-NC-SA


 

 

 

 

 

 

Que devons-nous faire si l’objet n’est pas un URI, mais une chaîne de caractères Dans 

ce cas, nous omettrons l’attribut « rdf:resource » et nous placerons notre valeur dans 

l’élément. Ainsi, pour représenter le contenu RDF suivant : 



2000/ 10/swap/pim/ 


"Professeur" 

nous pourrons utiliser le code XML qui suit : 

 

 

 

Professeur 

 

 

Encore une fois, les conventions relatives aux espaces de noms s’appliquent et nous 

pourrions remplacer le XML de l’exemple précédent par celui-ci : 

 

 

 

Professeur 

 

 



2000/ 10/swap/pim/ 



Donc, pour représenter l’ensemble des données RDF suivantes : 



http://www.w3.org/ "Daniel Lemire" 

2000/ 

10/swap/pim/ 



CC BY-NC-SA




http://www.w3.org/ "Professeur" 

2000/ 10/swap/pim/ 


nous utiliserons plusieurs éléments, les uns à la suite des autres, comme ceci : 

 

 

 

Daniel Lemire 

 

 

 

 

 

Professeur 

 

 

En pratique toutefois, nous ne répétons pas l’élément « Description » avec la même 

valeur d’attribut « about »; nous préférons la syntaxe qui suit : 

 

 

 

Daniel Lemire 

 

Professeur 

 

 

Et comme l’ordre est sans importance en RDF, nous pourrions aussi avoir le XML 

suivant : 

 

 

 

CC BY-NC-SA


Professeur 

Daniel Lemire 

 

 

 

5.2.5 Les classes en RDF 

Jusqu’à présent, nous n’avons pas représenté en XML l’affirmation suivante : 




02/22-rdf-syntax-ns#type 2000/ 10/swap/pim/ 


Évidemment, nous pouvons tout simplement écrire ceci : 

 

 

 

 

 

 

Mais, avouons-le, c’est assez peu lisible. Dans 

« http://www.w3.org/2000/10/swap/pim/contact#Person », « Person » est un fragment. 

Dans les cas où l’URI contient un fragment, nous représentons l’affirmation de la 

façon suivante : 

 

 

 

 

 

Nous remplaçons « rdf:Description » par le nom de la classe, soit « Person », avec 

le préfixe « http://www.w3.org/2000/10/swap/pim/contact# ». En pratique, cette dernière 

approche est presque toujours utilisée et son avantage devient évident quand on 

combine toutes les affirmations RDF de la première section : 

CC BY-NC-SA





en/ 

02/22-rdf-syntax-ns#type 2000/ 

10/swap/pim/ 


en/ 


en/ 



en/ 


2000/ 10/swap/pim/ 



2000/ 10/swap/pim/ 



2000/ 10/swap/pim/ 




"Professeur" 

Nous savons maintenant que nous pouvons représenter toutes ses informations par le 

XML suivant : 

 

 

 

Daniel Lemire 

 

Professeur 

 

 

C’est comme ça que nous pouvons écrire « Il y a une personne appelée Daniel Lemire 

dont l’adresse de courriel est dlemire@teluq.uqam.ca et qui est professeur. » en 

RDF/XML. 

5.2.6 Et s’il n’y a pas de symbole « # » dans l’URI 

Dans les exemples précédents, nous supposions que l’URI (du verbe) contenait 

un symbole « # », ce qui nous permettait de la décomposer en deux 

parties (nom et préfixe). Mais quoi faire si l’URI prend plutôt la forme 

« http://www.ondelette.com/employeur » Dans un tel cas, nous pouvons choisir de 

retenir « http://www.ondelette.com/ » comme préfixe et « employeur » comme nom. 

Nous pourrons donc représenter les données RDF suivantes : 



par le XML suivant : 

http:// 

www.ondelette.com/ 

employeur 

http://www.uquebec.ca/ 

CC BY-NC-SA


 

 

 

 

 

 

5.2.7 Des objets qui sont eux-mêmes des sujets 

Supposons que nous voulons dire que la pièce de théatre Othello a comme auteur 

William Shakespeare. En fait, nous voulons faire quatre affirmations : « Othello est 

une pièce de théatre », « Shakespeare est une personne », « Shakespeare est l’auteur 

d’Othello » et « Shakespeare a pour nom "William Shakespeare" ». Nous pourrions 

choisir de représenter en RDF ces quatre affirmations selon le tableau qui suit : 


http://www.othello.org/ http://www.w3.org/1999/ 


http://unuri.org/PieceDe- 

Theatre 

http://www.othello.org/ http://unuri.org/auteur http:// 

www.shakespeare.org 

http:// 

http://www.w3.org/1999/ http://unuri.org/Personne 


http:// 



http://unuri.org/nom 

"William Shakespeare" 

Nous pouvons utiliser la représentation XML suivante : 

 

 

 

 

 

 

William Shakespeare 

 

 

La représentation graphique du tableau RDF est : 

CC BY-NC-SA


http://www.othello.org/ 

type 

auteur 

PieceDeTheatre 

http://www.shakespeare.org 

type 

nom 

Personne 


Nous pouvons cependant le faire plus brièvement. Considérons d’abord le modèle suivant 

: 

 

 

 

 

(...) 

 

 

 

Nous avons vu que si nous mettons un nœud de texte là où les points « (...) » apparaissent, 

nous associerons « http://www.othello.org/ » avec un objet texte par le verbe 

« http://unuri.org/auteur ». Cependant, si nous mettons plutôt un élément muni d’un 

attribut « rdf:about », ce sera l’URI contenu dans l’attribut qui deviendra l’objet; nous 

gagnons alors la possibilité d’utiliser ce même objet comme sujet à son tour, comme 

dans cet exemple : 

 

 

 

 

 

 

 


 

CC BY-NC-SA


 

 

 

Ce nouveau document RDF est équivalent aux trois affirmations RDF du début, mais il 

est un peu plus court. 

Nous pourrions pousser l’expérience plus loin - ce qui peut devenir absurde - comme 

dans l’exemple qui suit : 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

Ce document est maintenant équivalent au tableau suivant : 


http://www.othello.org/ http://www.w3.org/1999/ 


http://unuri.org/PieceDe- 

Theatre 

http://www.othello.org/ http://unuri.org/auteur http:// 


http:// 

http://www.w3.org/1999/ http://unuri.org/Personne 

www.shakespeare.org 02/22-rdf-syntax-ns#type 

http://www.texte.org/ http://www.w3.org/1999/ http://unuri.org/Texte 

william 


http://www.texte.org/ http://unuri.org/contenu "William Shakespeare" 

william 

http:// 


http://unuri.org/nom http://www.texte.org/ 

william 

CC BY-NC-SA


5.2.8 Les contenants en RDF 

Il arrive fréquemment, en pratique, que l’on doive donner comme valeur à un objet, 

non pas une chaîne de caractères, mais plutôt un ensemble de chaînes de caractères. 

Par exemple, nous pouvons vouloir affirmer que « les étudiants du cours 101 sont Jean 

Roberge, Alexandre Coma et Julie LeChat ». Comment le faire Supposons que l’URI 

du cours est « http://www.teluq.uqam.ca/101 » et que le verbe correspondant à « être 

inscrit à un cours » est identifié par l’URI « http://www.education.com#inscription ». 

Nous pouvons alors essayer ceci : 

 

 

 

Jean Roberge 

Alexandre Coma 

Julie LeChat 

 

 

Cela équivaut à remplacer l’affirmation « les étudiants du cours 101 sont Jean Roberge, 

Alexandre Coma et Julie LeChat » par les trois affirmations « le cours 101 a comme 

étudiant Jean Roberge », « le cours 101 a comme étudiant Alexandre Coma », « le 

cours 101 a comme étudiant Julie LeChat ». Il n’est pas certain qu’une telle décomposition 

de l’affirmation préserve toujours le sens original. Par exemple, nous pourrions 

vouloir donner la liste complète de tous les étudiants dans le cours. RDF nous permet 

de regrouper tous les étudiants dans un seul élément « Bag » (sac, en anglais) comme 

ceci : 

 

 

 

 

 

Jean Roberge 


Julie LeChat 

 

 

 

 

Les éléments dans un « Bag » ne sont pas ordonnés. Nous pourrons remplacer le XML 

précédent par celui-ci, sans problème : 

 


xmlns="http://www.education.com#"> 

 

 

 

Julie LeChat 

Jean Roberge 


 

 

 

 

Si l’ordre importe, alors nous utiliserons un élément « Seq » (pour séquence), comme 

dans l’exemple suivant qui énonce les jours de la semaine, dans l’ordre : 

 

 

 

 

 

dimanche 

lundi 

mardi 

mercredi 

jeudi 

vendredi 

samedi 

 

 

 

 

Finalement, nous pourrions ne pas connaître exactement la valeur de l’objet, mais savoir 

que la valeur appartient à un ensemble fini de possibilités. Par exemple, si nous 

jouons à un jeu de détective et qu’il n’y a que trois coupables possibles (le majordome, 

la princesse et le seigneur), nous écrirons : 

 

 

 

 

 

majordome 

princesse 

seigneur 

CC BY-NC-SA

Questionnaire d’autoévaluation : Introduction au RDF 355 

 

 

 

 

5.2.9 RDFa 

Il peut sembler un peut lourd de créer des fichiers XML distincts pour stocker le RDF. 

Heureusement, il existe donc plusieurs approches pour inscrire le RDF à même des 

fichiers XHTML. La spécification RDFa permet d’inscrire du RDF directement au sein 

d’un document XHTML avec les attributs about et property. Voici un exemple d’annotation 

RDFa ajoutée à un élément XHTML : 

 

Wikinomics 

Don Tapscott 

2006-10-01 

 


Nous avons vu que le modèle RDF sert à décrire pratiquement n’importe quoi en associant 

des URI à tous les objets et relations. Les données RDF peuvent généralement 

être représentées en XML selon l’approche que nous avons décrite, ce qui permet de 

combiner les avantages du XML (format entièrement normalisé et non propriétaire, outils 

très disponibles, etc.), tout en gardant les avantages du RDF (contenu pouvant être 

traité par des machines, relative simplicité). Pour plus de détails, on peut consulter les 

articles du site mozilla.org sur le sujet (http://developer.mozilla.org/en/docs/RDF). 

Certains logiciels gratuits comme 4Suite (http://4suite.org/) peuvent traiter le contenu 

RDF/XML, mais ce n’est pas le cas des navigateurs web ou de la majorité des logiciels. 

Les graphiques de cette leçon furent générés avec 4Suite et inclus au texte en tant que 

SVG. 

5.3 Questionnaire d’autoévaluation : Introduction au 

RDF 

Avant de répondre à ce questionnaire, vous devez avoir lu le texte « Introduction au 

RDF ». 

CC BY-NC-SA



1. Parmi les affirmations qui suivent, lesquelles s’appliquent aux URI 


(a) On définit les URI en utilisant le RDF. 

(b) « teluq@teluq.ca » est un URI. 

(c) « teluq.ca » est un URI. 

(d) « http://www.ledevoir.com#directrice » est un URI. 

(e) Toute URL peut être utilisée comme URI. 

(f) « http://www.ledevoir.com/éditorial.html » est un URI. 

2. Parmi les affirmations qui suivent, lesquelles s’appliquent au RDF 


(a) Il s’agit d’une forme de XML. 

(b) Il s’agit d’un outil pour décrire des « documents » ou d’autres ressources 

au sein d’une organisation. 

(c) Le RDF peut servir pour représenter la connaissance de façon formelle. 

(d) Le RDF a été normalisé en 2001. 

(e) On définit le RDF en utilisant des URI. 

(f) Pour l’essentiel, le modèle RDF n’est constitué que de triplets : sujet, verbe, 

objet. 

(g) RDF est une norme ISO. 

3. Parmi les triplets qui suivent, lesquels peuvent former du RDF valable Choisissez 



http://www.teluq.ca/ http://www.w3.org/1999/ 


http:// 

www.institutions.org/ 

universite 

(a) 


"Téluq" 



http:// 

www.institutions.org/ 

universite 

(b) 


http://www.teluq.ca/ http://www.w3.org/1999/ 


"Université" 

CC BY-NC-SA


(c) 

4. Choisissez le tableau de triplets RDF qui correspond au document XML suivant : 

 

 

 

http://www.kapouta.org 

 

 



http://www.teluq.ca joe http://www.kapouta.org 

(a) 


http://www.teluq.ca http://www.teluq.ca/joe http://www.kapouta.org 

(b) 


http://www.teluq.ca http://www.teluq.ca/joe "http://www.kapouta.org" 

(c) 


 

 

 

 

 

 




(a) 



(b) 

CC BY-NC-SA




(c) 


 

 

 

 

La vie est belle 

 

 



http://www.teluq.ca http://www.teluq.ca/joe http://www.teluq.ca/jill 


http://www.teluq.ca http://www.teluq.ca/jill "La vie est belle" 

(a) 



http://www.teluq.ca jill "La vie est belle" 

(b) 




(c) 




(d) 


 

 

CC BY-NC-SA


 

 

La vie est belle 

 

 



http://www.teluq.ca http://www.teluq.ca/joe http://www.teluq.ca/jill 



(a) 



http://www.teluq.ca jill "La vie est belle" 

(b) 




(c) 




(d) 


http://www.teluq.ca http://www.w3.org/1999/ 


http://www.teluq.ca/ 

Description 



(e) 


1. (a) Non. On peut utiliser le concept d’URI sans connaître le RDF. 

(b) Non. Un URI doit spécifier le protocole comme dans les URL; il faut donc 

écrire « mailto:teluq@teluq.ca ». 

(c) Non. Il faut spécifier le protocole et utiliser plutôt « http://www.teluq.ca ». 

CC BY-NC-SA


(d) (Bonne réponse) Oui. Le symbole « # » peut être utilisé dans un URI (et 

dans une URL). Dans le cas des pages web, le symbole « # » est utilisé pour 

pointer vers un endroit spécifique dans la page web. Ce qui suit le « # » se 

nomme un « fragment ». (On utilise la norme RFC 1630.) 

(e) (Bonne réponse) Oui. Une URL est automatiquement un URI. 

(f) Non. On ne peut pas utiliser les accents dans un URI. 

2. (a) Non. Il est vrai qu’on peut représenter le RDF en XML, mais le RDF luimême 

n’est pas une forme de XML. 

(b) (Bonne réponse) Oui. C’est là la fonction essentielle du RDF. 


(d) Non. C’est en 1999. 

(e) (Bonne réponse) Vrai. 

(f) (Bonne réponse) Vrai. Tout se ramène à ce modèle simple. 

(g) Faux. Il s’agit d’une recommandation W3C. 

3. (a) (Bonne réponse) Oui. Il s’agit de trois URI, donc d’un triplet valable. 

(b) Non. Le sujet doit être un URI. 

(c) (Bonne réponse) Oui. L’objet peut être une chaîne de caractères, ou une 

autre valeur. 

4. (a) Non. L’objet n’est pas un URI et le verbe n’est pas « joe »; il faut porter 

attention à l’espace de noms. 

(b) Non. L’objet n’est pas un URI; dans ce cas, on doit utiliser l’attribut 

« rdf:resource ». 

(c) (Bonne réponse) Oui. L’objet n’est pas un URI. 

5. (a) Non. Le verbe n’est pas « joe »; il faut porter attention à l’espace de noms. 

(b) (Bonne réponse) Oui. L’objet est un URI. 

(c) Non. L’objet est un URI. 

6. (a) Non. Le premier des triplets n’apparaît pas dans le XML. 

(b) Non. Les verbes ne sont pas corrects; il faut porter attention à l’espace de 

noms. 

(c) (Bonne réponse) Oui. C’est correct. 

(d) Non. L’objet « http://www.kapouta.org » est un URI. 

7. (a) Non. Le premier des triplets n’apparaît pas dans le XML et « Description » 

est ici le type associé à l’URI « http://www.teluq.ca ». 

(b) Non. Les verbes ne sont pas corrects; il faut porter attention à l’espace 

de noms et « Description » est ici le type associé à l’URI 

« http://www.teluq.ca ». 

(c) Non. « Description » est ici le type associé à l’URI « http://www.teluq.ca ». 

(d) Non. L’objet « http://www.kapouta.org » est un URI et « Description » est 

ici le type associé à l’URI « http://www.teluq.ca ». 

(e) (Bonne réponse) Oui. C’est correct. 

CC BY-NC-SA

Le RDF par l’exemple 361 

5.4 Le RDF par l’exemple 

5.4.1 Introduction 

Avant de lire ce texte, vous devez avoir lu « Introduction au RDF », car nous supposons 

que vous comprenez la syntaxe RDF de base. 

Le RDF se retrouve un peu partout sur le web, parfois de façon « invisible », c’est-à-dire 

qu’il est souvent utilisé dans les échanges automatiques entre les logiciels. En outre, 

il est utilisé au sein des portails, par exemple. Voyons maintenant quatre applications 

RDF bien établies : 

Dublin Core Il s’agit sans doute de l’utilisation la plus connue et la plus répandue 

du RDF. La norme Dublin Core est assez simple et vise à décrire les travaux 

rendus disponibles sur le web (auteur, titre, date, etc.). Cette norme s’inspire de 

la bibliothéconomie. 

Creative Commons Il s’agit d’une façon de décrire les droits accordés sur le contenu 

placé sur le web. Par exemple, vous voulez savoir si vous pouvez recopier telle 

ou telle page web; si l’auteur a utilisé la norme Creative Commons, alors vous 

devriez pouvoir savoir ce qui est permis par l’auteur. 

FOAF La norme FOAF (« Friend Of A Friend » - « ami d’un ami ») permet de décrire 

un individu et les gens qu’il connaît. Cette norme sert à traiter les réseaux 

sociaux. 

RSS/RDF La norme RSS est utilisée par les blogues et sites de nouvelles. Le site 

mozilla.org a plusieurs articles sur le sujet (http://developer.mozilla.org/en/docs/ 

RSS). En gros, un document RSS/RDF contient une version XML des dernières 

nouvelles. Par la suite, plusieurs de ces fichiers XML peuvent être combinés pour 

créer un portail de nouvelles ou utilisés avec un outil-client de type « RSS aggregator 

» pour obtenir automatiquement les dernières nouvelles (voir, par exemple, 

blogbridge). 

5.4.2 Un exemple : Dublin Core 

La norme Dublin Core définit plusieurs « verbes » (au sein du RDF); on peut en consulter 

la liste à l’adresse http://dublincore.org/documents/dcmi-terms/ (en anglais). Cette 

norme a été publiée pour la première fois en juillet 1999. 

Le préfixe de la norme Dublin Core est « http://purl.org/dc/elements/1.1/ », du moins 

pour les éléments de base présentés ici. Voici les URI complets et leur signification : 

http://purl.org/dc/elements/1.1/creator Personne ou organisme qui est l’auteur du 

travail. 

http://purl.org/dc/elements/1.1/contributor Personne ou organisme qui a contribué 

à un travail, mais sans en être l’auteur. 

CC BY-NC-SA


http://purl.org/dc/elements/1.1/coverage Lieu et période correspondant au travail. 

http://purl.org/dc/elements/1.1/date Date associée au travail, généralement sous la 

forme AAAA-MM-JJ. Il peut s’agir de la date de publication, de création ou de 

la dernière révision. 

http://purl.org/dc/elements/1.1/description Brève description du travail. 

http://purl.org/dc/elements/1.1/format Format sous lequel est publié le travail. Si le 

travail est publié en HTML, alors on utilisera souvent « text/html » pour décrire 

le format. 

http://purl.org/dc/elements/1.1/identifier Code ou URI qui correspond de façon 

unique au travail. Si un travail est publié à une adresse web, on peut utiliser 

cette adresse comme URI; si c’est un livre avec un ISBN, on peut utiliser un URI 

de la forme « urn:ISBN:0-123-12345-1 ». 

http://purl.org/dc/elements/1.1/language Code ISO-639/ISO-3166 décrivant le travail. 

Si le travail est publié en français, on peut utiliser « fr-CA »; sinon, en 

anglais, ce serait « en-CA » (CA signifie Canada). 

http://purl.org/dc/elements/1.1/publisher Organisme responsable de la publication 

du travail. 

http://purl.org/dc/elements/1.1/relation Ressource liée au travail. Par exemple, 

pour un travail fait en classe, on peut établir un lien avec l’exposé du travail. 

http://purl.org/dc/elements/1.1/rights Contient souvent une affirmation permettant 

de savoir qui est propriétaire du travail (détenteur du droit d’auteur). 

http://purl.org/dc/elements/1.1/source Résumé du travail de quelqu’un d’autre. Cet 

URI permet de pointer vers la source originale. 

http://purl.org/dc/elements/1.1/subject Généralement, une liste de mots clés. 

http://purl.org/dc/elements/1.1/title Titre du travail. 

http://purl.org/dc/elements/1.1/type Type de la ressource (texte, image, etc.). Notons 

que le « type » est différent du « format ». Par exemple, une image peut être 

en format Jpeg ou Gif, un texte peut être en format Word ou ASCII. 

Voyons comment nous pouvons décrire ce texte que vous êtes en 

train de lire, en utilisant la norme Dublin Core. Attribuons-lui l’URI 

« http://www.uqam.ca/rdfexemples.html ». 


http://www.uqam.ca/ rdfexemples.html 

http://purl.org/ dc/ http://www.daniel- 

elements/1.1/creator lemire.com/fr/ 


http://purl.org/ dc/ "2004-07-27" 

elements/1.1/date 

http://www.uqam.ca/ rd- 

http://purl.org/ dc/ "Introduction au RDF" 

fexemples.html 


elements/1.1/title 

http://purl.org/ 

elements/1.1/type 

dc/ 

"text" 

CC BY-NC-SA




http://purl.org/ dc/ "fr-CA" 

elements/1.1/Language 


http://purl.org/ dc/ "RDF, Dublin Core, 

elements/1.1/subject Creative Commons, 

FOAF, RSS/RDF" 


http://purl.org/ dc/ "Copyright 2005 Daniel 

elements/1.1/rights Lemire" 


http://purl.org/ dc/ "Un document compresation 

elements/1.1/description nant des exemples d’utili- 

du RDF en gestion 

des connaissances." 


http://purl.org/ dc/ "text/html" 

elements/1.1/format 


http://purl.org/ dc/ http://www.uqam.ca/ rdfexemples.html 

elements/1.1/identifier 

Nous pouvons aussi représenter ce tableau en XML comme ceci : 

 

 

 

 

2004-07-27 

Introduction au RDF 

text 

fr-CA 

RDF, Dublin Core, Creative Commons, 

FOAF, RSS/RDF 

Copyright 2005 Daniel Lemire 

Un document comprenant des exemples 

d’utilisation du RDF en gestion des connaissances. 

text/html 

 

 

 

Nous pouvons aussi représenter ce tableau sous la forme d’un graphe : 

CC BY-NC-SA


http://www.daniel−lemire.com/fr/ 

creator 

2004−07−27 

date 


title 

identifier 

rdfexemples.html 

type 

Language 

subject 

rights 

text 

fr−CA 

RDF 

description 


format 



html 

Évidemment, Dublin Core est une norme RDF et non pas une norme XML. Il est donc 

possible d’exprimer du contenu Dublin Core sans passer par le XML. Nous pourrions 

très bien nous en tenir au tableau sujet/verbe/complément ou utiliser une autre syntaxe. 

Notons aussi que les conventions d’espace de noms s’appliquent et que l’ordre n’est 

pas important. Nous pouvons donc remplacer le XML précédent par celui-ci : 

 

 

 

 


2004-07-27 

text 

RDF, Dublin Core, Creative Commons, 

FOAF, RSS/RDF 




text/html 

 

fr-CA 

 

CC BY-NC-SA


 

Il existe des applications plus sophistiquées de la norme Dublin Core, mais nous avons 

ici l’essentiel. Vous pouvez dès maintenant cataloguer les ressources d’une entreprise 

en utilisant simplement ce que nous venons de présenter. Comme la norme est utilisée 

partout dans le monde, il sera possible d’échanger ces descriptions ou d’utiliser des 

logiciels communs pour le traitement ou l’affichage des informations. 

5.4.3 Un exemple : Creative Commons 

Une des limites apparentes de la norme Dublin Core est son incapacité à spécifier 

de façon précise les droits accordés sur un travail. Le problème est particulièrement 

fréquent sur le web : a-t-on le droit d’utiliser telle ou telle image gratuitement, de la 

reproduire, de la modifier, et ainsi de suite. 

Pour résoudre cette difficulté, les gens font appel à la norme Creative Commons, qui utilise 

le préfixe « http://web.resource.org/cc/ ». Cette norme définit une classe « Work » 

(travail, en anglais, ici au sens d’oœuvre), mais emprunte pratiquement tout le reste 

à Dublin Core qu’elle vient compléter. La norme Creative Commons a été proposée 

en 2001 par James Boyle, Michael Carroll, Lawrence Lessig, Hal Abelson, Eric Saltzman 

et Eric Eldred. 

Voici un exemple très simple d’une description utilisant la norme Creative Commons : 





http://web.resource.org/ 

cc/Work 


http://purl.org/ dc/ "Le RDF par l’exemple" 


Et voici la version XML correspondante : 

 

 

 

Le RDF par l’exemple 

 

 

Tout ce que nous avons affirmé dans ce dernier document, c’est que la page actuelle 

appartient à la classe « Work ». Dans l’état actuel des choses, nous affirmons par défaut 

qu’il n’est pas permis d’utiliser cette page, car nous n’avons attribué aucune permission. 

Supposons que l’auteur désire accorder le droit au lecteur de redistribuer, de modifier 

et de partager cette page, pour autant qu’il utilise la même licence. Nous 

CC BY-NC-SA


pourrions alors utiliser la licence « Attribution-ShareAlike 2.0 » dont l’URI est 

« http://creativecommons.org/licenses/by-sa/2.0/ ». Évidemment, nous pouvons aussi 

créer notre licence de toute pièce, mais dans l’exemple, nous utiliserons la licence 

« Attribution-ShareAlike 2.0 ». Pour faire un lien entre notre travail et une licence, 

nous utilisons le verbe dont l’URI est « http://web.resource.org/cc/license », comme ce 

qui suit; observez bien la dernière ligne du tableau. 






cc/Work 

http://www.uqam.ca/ rd- 

http://purl.org/ dc/ "Le RDF par l’exemple" 



cc/license 

fexemples.html 


http://creativecommons.org/licenses/by-sa/ 

2.0/ 

Nous pouvons aussi utiliser le XML correspondant : 

 

 

 


 

 

 

Voici la représentation sous la forme d’un graphe : 

rdfexemples.html 

{Work} 

title 

license 


http://creativecommons.org/licenses/by−sa/2.0/ 

Nous avons alors un document Creative Commons complet. Cependant, un problème 

demeure. Supposons qu’un logiciel fasse automatiquement une recherche 

pour vous et que vous ne désiriez obtenir que les textes que vous pouvez modifier 

librement. Il n’est pas évident pour une machine de comprendre que l’URI 

« http://creativecommons.org/licenses/by-sa/2.0/ » vous donne ce droit; d’ailleurs, une 

telle recherche n’est peut-être pas très simple pour un humain... 

Creative Commons définit trois verbes et des objets permettant de décrire une licence 

et une classe. Toutes les licences appartiennent à la classe ayant pour URI 

« http://web.resource.org/cc/License ». Les URI des trois verbes sont : 

CC BY-NC-SA


http://web.resource.org/cc/permits La licence le permet. Creative Commons 

définit trois URI pouvant être utilisés comme objet de ce 

verbe. Il y a d’abord « http://web.resource.org/cc/Reproduction », le 

droit de reproduire en tout ou en partie le travail. Il y a ensuite 

« http://web.resource.org/cc/Distribution », le droit de redistribuer le travail. 

Finalement, il y a « http://web.resource.org/cc/DerivativeWorks », le droit 

de modifier le travail. Évidemment, il est possible de définir ses propres objets. 

http://web.resource.org/cc/requires La licence pose comme condition. Creatives 

Commons définit quatre URI pouvant être utilisés comme objet de 

ce verbe : « http://web.resource.org/cc/Notice » pour spécifier qu’il faut 

reproduire intégralement les notes légales (licence et droits d’auteurs); 

« http://web.resource.org/cc/Attribution » pour spécifier qu’il faut attribuer à 

l’auteur le crédit du travail; « http://web.resource.org/cc/ShareAlike » pour spécifier 

que si l’on redistribue le travail, il faut le faire en gardant la même licence; 

« http://web.resource.org/cc/SourceCode » pour spécifier que le code source doit 

être redistribué. 

http://web.resource.org/cc/prohibits La licence interdit. Il n’y a qu’un seul 

URI défini par Creative Commons qui peut être utilisé avec ce verbe : 

« http://web.resource.org/cc/CommercialUse »; cela permet d’interdire l’utilisation 

à des fins commerciales. Encore une fois, il est possible de définir ses 

propres objets. 

Dans le cas de la licence « Attribution-ShareAlike 2.0 », nous pouvons la décrire 

comme suit : 


http://creativecommons.org/ 

licenses/by-sa/ 

2.0/ 



2.0/ 



2.0/ 



2.0/ 



2.0/ 



2.0/ 




cc/permits 


cc/permits 


cc/requires 


cc/requires 


cc/permits 


cc/License 


cc/Reproduction 


cc/Distribution 


cc/Notice 


cc/Attribution 


cc/DerivativeWorks 

CC BY-NC-SA





2.0/ 


cc/requires 


cc/ShareAlike 

Nous pouvons aussi utiliser le XML suivant : 

 

 

 

 

 

 

 

 

 

 

 

En pratique, nous combinons souvent le tout (description du travail et description de la 

licence) pour obtenir le XML suivant : 

 

 


 

 

 

 

 

 

 

 

 

 

 

Voilà! De cette manière, une machine pourra automatiquement déterminer quels droits 

l’utilisateur a sur une œuvre. Un logiciel pourrait automatiquement avertir l’utilisateur 

de ses obligations si jamais il tentait d’enregistrer sur son disque une copie de l’œuvre. 

Dans le cas d’une entreprise qui utilise beaucoup de contenu multimédia, l’utilisation 

de cette norme pourrait être très utile pour détecter automatiquement les violations des 

droits d’auteur. 

CC BY-NC-SA


5.4.4 Un exemple : FOAF 

Les personnes sont souvent ce qu’il y a de plus important dans une organisation; il 

n’est donc pas étonnant qu’on veuille utiliser le RDF pour les décrire. Pour ce faire, on 

utilise souvent la norme FOAF pour « Friend-Of-A-Friend », ou un ami d’un ami, en 

français, (préfixe http://xmlns.com/foaf/0.1/) qui définit la classe « Person » (personne, 

en anglais). 

Le projet FOAF a été lancé de façon informelle par Daniel Brickley en 1998. À 

l’époque, il avait mis un texte RDF ressemblant à ceci sur sa page personnelle : 

(Attention.- Il ne s’agit pas de RDF/XML valable.) 

 

xmlns:rdf="http://www.w3.org/TR/WD-rdf-syntax#"> 

 

Dan Brickley 

daniel.brickley@bristol.ac.uk 

 

 

 

 

 

 

La norme FOAF est très riche; mais à la base, on trouve les verbes suivants : 

http://xmlns.com/foaf/0.1/name Verbe pointant vers le nom de la personne (John 

Smith) 

http://xmlns.com/foaf/0.1/nick Verbe pointant vers le surnom informel de la personne 

(joblo). 

http://xmlns.com/foaf/0.1/title Verbe pointant vers le titre de la personne (docteur, 

monsieur, madame). 

http://xmlns.com/foaf/0.1/homepage Verbe pointant vers la page personnelle de la 

personne. 

http://xmlns.com/foaf/0.1/mbox Verbe pointant vers l’adresse électronique de la personne. 

http://xmlns.com/foaf/0.1/img Verbe pointant vers une image de la personne, la représentant 

spécifiquement. 

http://xmlns.com/foaf/0.1/depiction Verbe pointant vers une image représentant la 

personne. Contrairement à « img », l’image peut être une photo de groupe. 

http://xmlns.com/foaf/0.1/family_name Verbe pointant vers le nom de famille de la 

personne (Smith). 

CC BY-NC-SA


http://xmlns.com/foaf/0.1/givenname Verbe pointant vers le prénom de la personne 

(John). 

En XML, une description de l’auteur de ce document pourrait se présenter comme suit : 

 

 

 

Daniel 

Lemire 

 

lemire@uqam.ca 

 

 

 

Voici le graphe équivalent : 

Anonymous 

Person 

givenname 

family_name 

homepage 

mbox 

Daniel 

Lemire 

http://www.daniel−lemire.com/fr/ 

img 

lemire@uqam.ca 

zel2p.gif 

Notez que la balise « Person » n’a pas d’attribut « rdf:about ». Actuellement, il existe 

un débat sur cette question : Peut-on attribuer un URI unique à chaque individu et si 

oui, comment le choisir C’est un cas où l’URI du sujet est « implicite » : cela signifie 

que dans les triplets sujet/verbe/objet, le sujet a un URI « fictif », qui n’est valable que 

dans le cadre du document que l’on traite. Autrement dit, le programme qui traite le 

document doit allouer dynamiquement un URI au sujet pour la durée du traitement. 

Rappelons-nous, en effet, que la norme RDF permet d’omettre le sujet, mais que si le 

sujet est spécifié, il doit être un URI. 

Nous pouvons imaginer que la norme FOAF sera éventuellement utilisée pour représenter 

les réseaux sociaux, les organisations, et ainsi de suite. Une fois l’information 

CC BY-NC-SA


sociale représentée de façon formelle, nous pouvons croire qu’il sera possible de poser 

des questions à un ordinateur de l’ordre suivant : Est-ce que je connais quelqu’un qui 

connaît quelqu’un travaillant chez IBM 

5.4.5 Un exemple : RSS/RDF 

La version 1.0 de la norme RSS est un exemple de RDF. Cette norme dont l’acronyme 

n’a pas de définition établie, sert à représenter des fils de nouvelles. Elle a été imaginée 

par la compagnie Netscape et servait alors à la production du portail Netscape (1999). 

Elle est devenue très populaire et on trouve maintenant des milliers de fils de nouvelles 

en format RSS dans le monde. Par exemple, sur http://www.yulblog.org/, il y a des 

centaines de blogues écrits par des Montréalais et la plupart ont un fil de nouvelles en 

format RSS. 

Une nouvelle, appelée « item » en RSS, prend la forme suivante : 

 

 

 

La bourse fait faillite 

http://www.nouvelles.com/nouvelles1.html 

 

Aujourd’hui, on a appris que la bourse a fait faillite. 

 

 

 

Nous constatons qu’il y a une classe (item) et trois verbes (title, link, description) qui 

représentent respectivement le titre, l’URL et le contenu de la nouvelle. 

Un document RSS est une liste d’items. Voici un document RSS : 

 

 

 

Un site de nouvelles 

http://www.nouvelles.com/ 

 

Nouvelles.com est un superbe site de nouvelles 

 

 

 

CC BY-NC-SA


 

 

 

 

 

 

 

 

Nous constatons une classe « channel » (canal, en anglais) qui contient un titre, un 

URL (link) et une description. Il y a aussi une liste de nouvelles (item). Généralement, 

nous combinons le tout dans un seul fichier, comme ceci : 

 

 

 


http://www.nouvelles.com/ 

 


 

 

 

 

 

 

 

 

 

 

 



 


 

 

 

Rien ne va plus à l’école 


 

Un étudiant se serait rendu coupable d’apprentissage. 

 

CC BY-NC-SA


 

 

Les applications du RSS sont multiples. Supposons que votre organisation collabore 

avec plusieurs autres organisations et que vous vouliez rendre disponibles, sur une seule 

page web, toutes les nouvelles de toutes les organisations dont vous faites partie. Si 

chaque organisation rend disponible sur le web un document RSS toujours mis à jour, 

vous pouvez facilement récupérer les nouvelles de chacun et les afficher à un seul 

endroit. Au lieu de solliciter tous les membres par courriel, les fils de nouvelles RSS 

permettent à une machine de faire un tri et de personnaliser le contenu. 

La norme RSS est en voie d’être remplacée par la norme Atom. Un des avantages du 

nouveau format Atom est que chaque nouvelle doit avoir un identifiant unique ce qui 

permet d’éviter les doublons. Cependant, la norme RSS risque d’être toujours utile 

pendant bien des années. Atom n’est pas en RDF/XML. En voici un exemple : 

 

 



 

2003-12-13T18:30:02Z 

 

John Doe 

johndoe@example.com 

 

urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6 

 


 

urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a 

2003-12-13T18:30:02Z 


 

 

 


Nous avons étudié quatre applications importantes du RDF sur le web. Le nombre 

d’applications est toutefois beaucoup plus important. 

CC BY-NC-SA


Il faut garder à l’esprit que le RDF n’est pas le XML et que le XML ne sert qu’à 

représenter le RDF (et encore, ce n’est pas toujours possible). Il est probable que la 

syntaxe utilisée pour représenter le RDF en XML va encore évoluer. 

Pour en apprendre davantage sur le RDF, nous vous suggérons le livre de Shelley Powers, 

Practical RDF, publié chez O’Reilly en juillet 2003 (350 pages), en anglais seulement 

et coûtant environ 60 $. 

5.5 Questionnaire d’autoévaluation : Le RDF par 

l’exemple 

Avant de répondre à ce questionnaire, vous devez avoir lu le texte « Le RDF par 

l’exemple », qui est la suite du texte « Introduction au RDF ». 


1. Parmi les affirmations suivantes, lesquelles s’appliquent à la norme Dublin Core 


(a) La première version de Dublin Core a été publiée en 2001. 

(b) Dublin Core est une forme de RDF. 

(c) Dublin Core est une forme de XML. 

(d) La norme Dublin Core peut être utilisée pour décrire des photographies ou 

objets multimédias. 

2. Choisissez l’affirmation qui décrit le mieux l’information contenue dans ce document 

Dublin Core : 

 

 

 

Alec Castonguay 

Harper est prêt pour de nouvelles élections 

2004-09-30 

 

 


(a) Il y a un article à l’URL « http://www.ledevoir.com/2004/09/30/65081.html » 

écrit par quelqu’un nommé Alec Castonguay; l’article a été écrit le 30 

septembre 2004 et porte le titre « Harper est prêt pour de nouvelles 

élections ». 

CC BY-NC-SA

Questionnaire d’autoévaluation : Le RDF par l’exemple 375 

(b) Le document ayant l’URI « http://www.ledevoir.com/2004/09/30/65081.html », 

portant le titre « Harper est prêt pour de nouvelles élections » et daté du 30 

septembre 2004, a été écrit par quelqu’un nommé Alec Castonguay. 

(c) Alec Castonguay a écrit l’article ayant l’URI 

« http://www.ledevoir.com/2004/09/30/65081.html » et le titre « Harper 

est prêt pour de nouvelles élections », le 30 septembre 2004. 

3. Parmi les affirmations suivantes, lesquelles s’appliquent à la norme Creative 

Commons 


(a) La première version de Creative Commons a été publiée en 2001. 

(b) Creative Commons est une forme de RDF. 

(c) Creative Commons sert surtout à décrire le contenu des documents. 

4. Choisissez l’affirmation qui décrit le mieux l’information contenue dans ce document 

Creative Commons : 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


(a) Ce document n’est pas valable. 

CC BY-NC-SA


(b) Le document à l’URL « http://www.mavieestbelle.com/index.html » peut 

être modifié et reproduit dans un contexte non commercial ou reproduit 

sans modification dans un contexte commercial. 

(c) Le document représenté par l’URI « http://www.mavieestbelle.com/index.html » 

peut être modifié et reproduit dans un contexte non commercial ou reproduit 

sans modification dans un contexte commercial. 

5. Comment peut-on expliquer que le premier document FOAF en XML n’était pas 

du RDF valable Choisissez toutes les réponses qui s’appliquent. 

(a) Au départ, FOAF ne devait pas être du RDF. 

(b) FOAF est un projet informel qui ne respecte pas toujours les normes. 

(c) La première spécification du RDF date de 1999. 

6. Lesquelles de ces affirmations sont vraies Choisissez toutes les réponses qui 


(a) Pour l’essentiel, les applications RDF présentées dans ce cours, telles que 

Dublin Core, datent de 1999. 

(b) Un document FOAF doit être du RDF valable. 

(c) RSS est une technologie émergente peu utilisée. 


1. (a) Non. C’est en juillet 1999. 


(c) Non. L’information Dublin Core est souvent écrite en XML, mais n’a pas 

à l’être. 

(d) (Bonne réponse) Oui. En fait, la norme Dublin Core s’applique à toute 

création humaine (livres, films, etc.). 

2. (a) Non. Le lien « http://www.ledevoir.com/2004/09/30/65081.html » est un 

URI, pas nécessairement un URL. 


(c) Non. On ne sait pas quand l’article a été écrit : la date dans Dublin Core 

n’a pas une signification établie. La date pourrait plutôt être la date de publication. 

3. (a) (Bonne réponse) Correct. 


(c) Non. Creative Commons sert surtout à décrire les droits associés à des documents. 

4. (a) Non. Il s’agit un document valable. 

CC BY-NC-SA


(b) L’adresse « http://www.mavieestbelle.com/index.html » doit être traitée 

comme un URI et non comme une URL; il pourrait ne pas y avoir de document 

à cette adresse. 


5. (a) Non. Tout document FOAF doit être du RDF valable. 

(b) Non. Le premier document FOAF était une forme de RDF, mais on n’écrit 

plus le RDF de cette façon. 

(c) (Bonne réponse) Effectivement. En 1998, Daniel Brickley était un précurseur 

du RDF. 

6. (a) (Bonne réponse) C’est vrai. Seul Creative Commons est plus récent. 

(b) (Bonne réponse) C’est vrai, même si l’exemple original de Dan Brickley 

n’est pas du RDF/XML valable. 

(c) Au contraire, des milliers de portails et des millions de sites web utilisent 

maintenant RSS. 



Ce travail porte principalement sur le RDF et compte pour 10 % de la note globale du 

cours. Il contribue à l’atteinte de l’objectif suivant : 


Le travail comporte sept exercices : les cinq premiers valent un point chacun et le 

sixième, qui porte sur le XSLT et contribue ainsi à renforcer les apprentissages du 

module 3, vaut 4 points, alors que le dernier compte pour un point, pour un total de 

10 points. 


Nous vous recommandons d’avoir terminé les activités d’autoévaluation du module 5 

avant de faire ce travail noté. De plus, comme le sixième exercice exige une bonne compréhension 

du XSLT, vous devriez avoir terminé le module 3 avant de l’entreprendre. 

Lorsque vous aurez terminé le travail, transmettez à votre personne tutrice, par courriel, 

un seul document (Word 97/2000/XP, ODF, PDF, RTF ou en format texte) comprenant, 

pour chaque exercice, le tableau, le code XML ou le contenu de votre document XSLT. 

Ne transmettez pas vos solutions en plusieurs fichiers. Ne transmettez pas une 

archive compressée (zip ou autre). L’objet de votre courriel doit commencer par 

« [INF6450][TRAVAIL6] »; dans le message, indiquez votre nom, votre numéro 

CC BY-NC-SA


d’étudiant (8 chiffres), la date de remise de votre travail et le nom de votre personne 

tutrice, ainsi que les mentions « Travail noté 6 » et « INF 6450 ». Il s’agit 

d’un travail personnel et vous ne devez pas partager vos solutions. 

Dans un tableau de triplets, les objets qui ne sont pas des URI, doivent être placés entre 

guillements (" "). 


Représentez, dans un tableau de triplets (sujet, verbe, objet), le document RDF/XML 

suivant : 

 

 

 

Site de l’UQÀM 

 

 

 


Écrivez un programme Java qui utilise l’API DOM pour extraire tous les titres des 

items d’un document RSS 1.0. Vous pouvez supposer que le fichier réside sur votre 

disque. Ne joignez pas un fichier à l’extension java. 


Représentez, dans un tableau de triplets (sujet, verbe, objet), l’exemple en RDF qui suit 

et qui provient de la norme PRISM. 

 

 

 

 

 

 

John Peterson 

 

 

CC BY-NC-SA


 

 

Greece 

Grece 

 

 

 

 


Ecrivez un document XML/RDF correspondant au tableau suivant : 


http://www.uqam.ca http://www.uquebec.ca/ 

nom 

"UQÀM" 


La licence identifié par l’URI « http://www.mondomaine.ca/licence » permet la reproduction, 

la distribution et la modification des œuvres. Décrivez cette licence en utilisant 

Creative Commons et le format RDF/XML. 


Note.- Cet exercice vaut 4 points et est substantiellement plus difficile que les exercices 

précédents. 

Avant de réaliser l’exercice... 

Il peut arriver qu’on veuille annoter un document XHTML avec Dublin Core ou avec 

un autre vocabulaire RDF, mais sans vouloir utiliser la notation RDF/XML. L’annotation 

est particulièrement facile si aucun des objets n’est un URI. Pour y arriver, nous 

utiliserons des éléments « meta » et « link » placés dans l’élément « head » du document. 

Considérons l’exemple qui suit : 

 

 

 

 

 

CC BY-NC-SA


 

 

 

 

 

 

un petit document 

 

 

Ceci est un document XHTML annoté avec Dublin Core. 

 

 

Cette façon de faire est documentée par le mémo disponible à l’adresse http:// 

www.ietf.org/rfc/rfc2731.txt. Il n’est toutefois pas nécessaire de consulter ce mémo. 

Aux fins de cet exercice, nous allons supposer que seuls deux types de structures sont 

utilisés. D’abord, l’élément « link » peut être utilisé pour définir un préfixe, comme 

ceci : 

 

D’autre part, le préfixe peut être utilisé pour faire un lien entre le document courant et 

un sujet : 

 

Prenons comme exemple les quatres éléments suivants placés dans un document 

XHTML à l’adresse « http://www.uqam.ca/index.html » : 

 

 

 

 

Cette notation aura alors la signification suivante en RDF : 


http://www.uqam.ca http:// 

"c" 

www.mondomaine.com/ 

a 

http://www.uqam.ca http:// 

www.mondomaine.com/ 

2/g 

"f" 

En notation RDF/XML, nous avons : 

 


> 

 

c 

f 

 

 

Notez qu’aucun des objets n’est un URI. 

Exercice à réaliser... 

Écrivez un document XSLT qui, étant donné un document XHTML annoté selon cette 

méthode, donne le document RDF/XML correspondant, en supposant que le document 

courant possède l’URI « http://mondocument.org ». Pour que l’on puisse voir la solution 

dans Firefox, produisez un document HTML qui contient le code du document 

RDF/XML comme dans l’exemple qui suit : 

 

 

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

<rdf:RDF 

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" > 

<rdf:Description rdf:about="http://mondocument.org"> 

<title 

xmlns="http://purl.org/dc/elements/1.1/"> 

le titre de mon document 

</title > 

</rdf:Description> 

</rdf:RDF> 

 

En somme, votre document XSLT doit produire un document débutant par la balise 

html et contenant le document RDF/XML écrit avec des appels d’entités (<,>). 

Toute solution qui utilisera les éléments XSLT « xsl:key », « xsl:param » et 

« xsl:variable » sera refusée; une note de zéro sera accordée. 

Voici quelques indices... 

– Les documents XHTML utilisent l’espace de noms 

« http://www.w3.org/1999/xhtml ». Pour pouvoir les traiter en XSLT, il vous 

faut définir cet espace de noms comme dans cet exemple : 

 


xmlns:xhtml="http://www.w3.org/1999/xhtml" 

> 

 

<rdf:RDF></rdf:RDF> 

 

– Les fonctions XPath « substring-before » et « substring-after » peuvent vous 

être utiles. La valeur de l’expression XPath « substring-before(’meta.dc’,’.’) » est 

« meta », alors que la valeur de l’expression « substring-after(’meta.dc’,’.’) » est 

« dc ». 


Le site flickr permet de chercher des photographies publiées avec une licence Creative 

Commons. Visitez la page http://www.flickr.com/photos/guppiecat/1351724368/ 

in/set-72157601927001088/ et trouvez la licence Creative Commons. Écrivez-la en 

XML. 

CC BY-NC-SA

Annexe A : Glossaire 

Appel d’entité : Un appel d’entité est une suite de caractères (bout de texte) qui commence 

par une esperluette ( & ) et se termine par un point-virgule ( ; ). Les appels 

d’entité suivants font partie de la définition du XML : 

appel d’entité 

résultat 

< < 

& 

& 

> > 

" " 

' ’ 

Attribut : Un attribut est un nom XML qui doit respecter les mêmes règles que les 

noms XML des balises; il est immédiatement suivi d’un signe d’égalité ( = ) et d’une 

valeur placée entre guillemets. Par exemple, la balise a un attribut 

(age="5") dont le nom XML est "age". Une balise peut avoir plusieurs attributs, comme 

, mais chacun doit avoir un nom XML différent; la balise 

n’est pas autorisée. 

Balise : Une balise est un texte commençant par le signe < et se terminant par le signe 

>, délimitant un élément. Il existe trois types de balises en XML : les balises qui commencent 

un élément, les balises qui terminent un élément et les balises d’élément vide. 

Par exemple, est une balise qui ouvre un élément. Une balise qui commence 

par marque que l’élément est vide, comme . Une déclaration 

de type de document (), une déclaration XML (), un 

commentaire () ou une région CDATA () ne sont pas des balises. 

383

Glossaire 384 

Bien formé : Un document XML bien formé respecte la grammaire XML et il peut 

être lu par n’importe quel parseur XML générique. 

Commentaire : Un commentaire commence par ; entre ces 

deux bornes, il ne peut y avoir deux tirets successifs (--), mais n’importe quoi d’autre 

peut s’y retrouver. 

CSS : Cascading StyleSheet. 

Déclaration de type de document : Une déclaration de type de document prend la 

forme , où l’on met à la place des premiers trois 

points le nom XML de l’élément-racine que le document doit avoir, et à la place des 

deuxièmes trois points, une URL vers le document DTD. 

Déclaration XML : La déclaration XML ressemble à s’y méprendre à une instruction 

de traitement et prend la forme . Le contenu d’une déclaration XML 

comporte généralement au maximum trois attributs : version="...", encoding="..." et 

standalone="...". La version du XML la plus utilisée est la 1.0; bien que la version 

1.1 existe, elle est fort peu utilisée. On utilisera souvent une déclaration XML 

avec « encoding="ISO-8859-1" » pour pouvoir utiliser les accents dans le document; 

par défaut, on ne peut pas utiliser les accents dans un document XML, sans des outils 

supportant les normes UTF-8/UTF-16. L’attribut « standalone » prend les valeurs yes 

ou no, selon que l’on veut que la DTD externe soit lue ou pas. La déclaration XML 

doit obligatoirement être au tout début du document ou être carrément absente : même 

un espace avant n’est pas permis. 

DocBook : C’est un format de document souvent utilisé pour la documentation technique. 

DOM (Document Object Model) : Le terme « DOM » a deux significations : un ensemble 

d’API utilisant un modèle en arbre ou un certain modèle en arbre. 

DTD (Définition de Type Document) : Une DTD permet de définir un type de document 

XML en spécifiant des contraintes sur les éléments, les attributs et leur contenu. 

Un document XML qui satisfait ces contraintes et qui est bien formé est dit valable. 

Élément : Un élément est l’ensemble du texte borné par deux balises ayant le même 

nom XML, comme et . On dit que l’élément a le nom 

XML « lavie ». L’élément hérite des attributs de sa balise de départ : l’élément possède l’attribut « age="5" ». Il est à noter que la casse est significative 

en XML : les balises < A > et < a > n’ont pas le même nom XML. Lorsque l’élément 

est vide, c’est-à-dire sans contenu, on peut remplacer par , pour être plus bref. Par ailleurs, un élément peut contenir d’autres éléments, comme 

dans , ou du texte ou du texte et des éléments, comme fdfsdfd. 

Si un élément contient l’élément de début ou de fin d’un 

élément, alors il doit aussi contenir l’autre. Ainsi, un élément peut être contenu par un 

autre ou non, mais deux éléments ne peuvent se chevaucher, comme , 

qui est du XML mal formé. 

CC BY-NC-SA

Glossaire 385 

Élément-racine : Tout document XML bien formé doit avoir un élément-racine, et un 

seul. Tous les autres éléments doivent être contenus dans cet élément-racine. 

Espace de noms : Les espaces de noms permettent d’utiliser plusieurs vocabulaires 

XML en même temps. 

Extensible : Voir Métalangage. 

Graphe : Un graphe est un ensemble de nœuds liés par des relations d’un nœud à un 

autre. 

Graphe dirigé : Un graphe est dirigé si les relations sont à sens unique. 

Graphe annoté : Un graphe est annoté si les relations entre deux nœuds peuvent être 

de différentes natures. 

HTML (HyperText Markup Language) : Le HTML est un langage à base de balises. 

La majorité des documents sur le web sont écrits en HTML. 

Instruction de traitement : L’instruction de traitement ne fait rien en soit, mais peut 

indiquer aux programmes comment obtenir un certain résultat. Une instruction de traitement 

débute par « < » et se termine par « > »; immédiatement après le « < », un 

nom XML valable doit apparaître et tous les noms XML valables sont autorisés à l’exception 

de xml, Xml, XMl, XML, XmL, xMl, xML et xmL. Ainsi n’importe quel autre 

texte peut être utilisé, mais il faut faire des appels d’entités pour « < » et « & », comme 

pour n’importe quel contenu textuel XML. 

Métalangage : Le XML est un « métalangage » permettant d’échanger de l’information, 

principalement sur le web. On dit que c’est un « métalangage » parce qu’il permet 

de créer de nouveaux langages pour l’échange d’informations, mais qu’il ne constitue 

pas un langage en soi. On dit donc que le XML est « extensible » (peut être étendu) et 

que c’est un métalangage : les deux affirmations ont le même sens et notent la capacité 

du XML à s’adapter à des besoins différents. 

Nom XML : Le nom XML d’une balise est le texte suivant le symbole « < » ou 

«

Glossaire 386 

URI : C’est une adresse Internet fictive. L’URI agit un peu comme le numéro d’assurance 

sociale des vocabulaires XML. 

Valable :: Un document est valable s’il répond à certains critères de base de l’application 

XML. Un document XML qui est bien formé, qui en plus satisfait aux contraintes 

dictant quels éléments et attributs peuvent être utilisés, et dans quel ordre et avec quel 

contenu, est dit valable. 

Vocabulaire XML : Un « vocabulaire XML » est un ensemble de noms de balises et 

d’attributs ayant une signification donnée. Un vocabulaire XML peut être associé à un 

document DTD. 

XHTML : Le XHTML est un format hybride : il tient à la fois du HTML et du XML. 

XML : eXtensible MarkupLanguage. 

XSL : eXtensible Stylesheet Language. 

XSLT : XSL Transformations. 

XSL-FO : eXtensible Stylesheet Language Formatting Objects. 

CC BY-NC-SA

Annexe B : Webographie XML 

Tous les liens ont été vérifiés en février 2007. 

1 Blogues 

– http://www.daniel-lemire.com/blogue/category/xml/ (blogue du cours) 

– http://www.tbray.org/ongoing/ 

– http://formats-ouverts.org/blog/ 

2 Cours en ligne, en français 

– http://www.commentcamarche.net/xml/xmlintro.php3 

– http://www.laltruiste.com/coursxml/sommaire.html 

3 Cours en ligne, en anglais 

– http://www.w3schools.com/ 

– http://www.w3schools.com/xml/default.asp 

– http://www.w3schools.com/xml/xml_examples.asp 

4 Liens généraux, en français 

– L’espace XML francophone : www.xmlfr.org 

– Rubrique XML chez Wikipedia 

387

Webographie XML 388 

5 Articles, en français 

– A. Crochet-Damais, Microsoft Office 2003 : le format XML pointé du doigt 

6 Articles, en anglais 

– J. Hunt, et al. Why use DITA to produce HTML deliverables 

– D. Terdiman, Weather Data for the Masses 

7 Références tirées du site Wikipedia (anglais) 

7.1 Spécification XML 

– Spécification XML annotée : http://www.xml.com/axml/testaxml.htm 

– Site du World Wide Web Consortium : http://www.w3.org/ 

– Page d’accueil XML du World Wide Web Consortium : http://www.w3.org/XML/ 

– Spécification XML 1.1 : http://www.w3.org/TR/xml11 

– Spécification XML 1.0 : http://www.w3.org/TR/REC-xml 

7.2 Software 

– Éditeur XML open : http://www.philo.de/xmledit/ 

– Librairie XML open pour Delphi/Kylix : http://www.philo.de/xml/ 

– Éditeur jEdit : http://jedit.org 

7.3 Ressources pour les développeurs 

– FAQ XML : http://www.ucc.ie/xml/ 

– xml.com, développement et ressources : http://www.xml.com/ 

– Cafe con Leche, nouvelles et ressources XML : http://www.cafeconleche.org/ 

– XML Cover Pages : http://xml.coverpages.org/ 

– Page web des développeurs IBM : http://www-106.ibm.com/developerworks/xml/ 

– Site de nouvelles pour les développeurs XML : http://www.xmlhack.com/ 

– Mailing liste XML-L : http://listserv.heanet.ie/xml-l.html 

– DTD et schemas XML : http://www.XMLPatterns.com/ 

– Tutoriel sur Relax NG : http://www.oasis-open.org/committees/relax-ng/tutorial- 

20010810.html (traduit en français : http://xmlfr.org/oasis/committees/relax-ng/ 

tutorial-20011203-fr.html) 

– Les problèmes du XML : http://c2.com/cgi/wikiXmlSucks 

– XML : http://www.ericdigests.org/2000-4/xml.htm 

CC BY-NC-SA

Liens vers des livres portant sur le XML, en anglais 389 

– XML Linking : état de l’art : http://chinese-school.netfirms.com/xlink.html 

– Un outil XSLT (Markup of XML contents) : http://www.ultra-fluide.com/ressources/ 

en/semark/presentation.htm 

8 Liens vers des livres portant sur le XML, en anglais 

– XML: Managing Data Exchange (wikibook) 

– XML in a Nutshell, by Harold and Means 

– Beginning XML, 3rd Edition, by David Hunter, Andrew Watt, Jeff Rafter. 

– Learning XML, by Erik T. Ray. 

– XML Schema, by Eric Van Der Vlist. 

– Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX, 

by Elliotte Rusty Harold. 

CC BY-NC-SA

Annexe C : Pense-bête DTD 

: Déclaration de type 

de document 

: Instruction 

: Élément optionnel 

* : Élément pouvant être présent plus d’une fois (de 0 à l’infini) 

+ : Élément présent au moins une fois et qui peut être présent plusieurs fois 

| : Ou 

#PCDATA : Que du texte 

: Spécifie que l’élément « X » a l’attribut 

« Y » 

CDATA : Attribut contient du texte 

#REQUIRED : Attribut obligatoire 

#IMPLIED : Attribut optionnel 

#FIXED : Attribut fixé avec une valeur 

: L’entité « nomEntiteX » prend la valeur 

« Yvaleur » 

: Localement, l’entité « nomEntiteX » prend 

la valeur « Yvaleur » dans la DTD 

391

Annexe D : Pense-bête HTML 

Balise 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Signification 

paragraphe 

liste non ordonnée 

élément de la liste 

liste ordonnée 

élément de la liste 

tableau 

ligne 

cellule 

italique 

italique (généralement) 

gras 

gras (généralement) 

souligné 

393

Pense-bête HTML 394 

Balise 

 

 

 

 

 

 

Signification 

liste de définitions 

terme à définir 

définition du terme 

ligne horizontale 

affiche une image 

texte hyperlien 

texte marqueur 

CC BY-NC-SA

Annexe E : Pense-bête XSLT 

Document XSLT de base 

 

 

 

« xsl:template » : Permet de définir un modèle avec un élément comme ; à chaque élément facture trouvé, le processeur XSLT applique le 

modèle correspondant. 

« xsl:apply-templates » : Cet élément donne le résultat obtenu par l’application de 

modèles (éléments « xsl:template »). 

« xsl:value-of » : Donne la valeur textuelle d’une expression XPath. Par exemple, 

l’instruction où « ... » est le nom de l’élément donne le 

texte contenu dans l’élément, les balises en moins. 

« » : Pour effectuer la sélection des attributs. Ici, 

l’attribut « nas » de l’élément « personne » (). 

Expression XPath avec « . » (un point) : Indique le nœud courant. Par exemple, 

l’instruction donne le contenu textuel de l’élément courant. 

Expression XPath avec « / » (barre oblique) : Permet d’effectuer la sélection 

de nœuds contenus dans des éléments. L’instruction « » donne le contenu textuel des éléments « prenom » contenus 

dans les éléments « nom » de l’élément courant. La barre oblique ( / ) peut aussi représenter 

le nœud-racine; ainsi, l’expression « /maison » sélectionne l’élément-racine, si 

et seulement s’il se nomme « maison ». 

Expression XPath avec « @ » : Permet d’effectuer la sélection des attributs. L’instruction 

« » donne le contenu textuel de l’attribut 

« nas » de l’élément courant. 

395

Pense-bête XSLT 396 

(accolades) : Pour spécifier la valeur d’un attribut; par exemple, avec l’expression 

, le processeur XSLT va remplacer ... par la valeur de l’expression 

XPath « ... » et s’il s’agit du nom d’un élément, le contenu textuel de l’élément 

y sera inséré. 

Expression XPath avec « .. » (deux points successifs) : Permet d’obtenir la valeur 

de l’élément dans lequel le nœud courant est situé. On peut aller chercher le parent du 

parent avec l’instruction . 

Expression XPath avec « // » (deux barres obliques) : Permet de sélectionner tous les 

éléments et sous-éléments qui sont dans l’élément ou nœud courant. Par exemple, l’instruction 

donne le nombre total d’éléments 

« cours » contenus dans l’élément ou nœud courant, incluant les éléments « cours » 

contenus dans les sous-éléments. 

Expression XPath avec « * » (astérisque) : Permet de sélectionner tous les éléments 

(mais pas les attributs ou les nœuds de texte) qui sont dans l’élément courant. Une 

expression avec « @* » sélectionne tous les attributs d’un élément. 

Expression XPath avec « | » (barre verticale) : Permet de sélectionner en utilisant 

plusieurs expressions à la fois; cette expression signifie « ou ». L’expression 

« nom|prenom » sélectionnera tous les éléments « nom » et « prenom » dans l’élément 

courant. 

« » : Permet de sélectionner le nom d’un élément 

(et pas son contenu). Pour sélectionner le nom du parent, il faut utiliser « .. » au lieu de 

« . ». 

Fonction XPath « count » : Permet de compter le nombre de nœuds (éléments) sélectionnés; 

par exemple « count(montant) » compte le nombre d’éléments « montant ». 

Fonction XPath « sum » : Permet de faire la somme des valeurs numériques dans 

les nœuds (éléments) sélectionnés; par exemple « sum(montant) » fait la somme des 

valeurs numériques dans les éléments « montant ». 

« xsl:number » : Permet de numéroter des éléments correspondant à une expression 

avec l’attribut « count »; un exemple d’utilisation : donnera le chiffre 3 pour le troisième élément « montant » contenu dans un même 

élément. 

Attribut « mode » : Permet d’avoir plusieurs modèles pour une même expression; 

s’applique aux éléments « xsl:apply-templates » et « xsl:template »; par exemple, 

ou . 

Fonction XPath « generate-id » : Permet de générer un identifiant unique pour chaque 

nœud d’un document XML comme dans l’expression « generate-id(.) ». 

« xsl:choose » et « xsl:if » : permet de tester des conditions avec les symboles « < », 

« = », « != », « or », « and », « > », « >= », «

Pense-bête XSLT 397 

montant 

 

 

donne le nom de l’élément si l’élément courant est un élément « montant » ou alors, le 

symbole « ». L’instruction XSLT 

2 maisons 

donne le chiffre 2, s’il y a deux éléments « maison » dans l’élément courant. 

Notion de liste d’éléments en XPath : Équivalent des tableaux en Java ou C/C++, 

mais la numérotation des éléments débute à 1; on utilise les crochets pour accéder aux 

éléments de la liste. L’expression XPath « para[1] » sélectionne le premier élément 

nommé « para ». L’expression « para[1]/em[2] » sélectionne le second élément « em » 

contenu dans le premier élément nommé « para ». 

Utilisation de XSLT comme base de données : Par exemple, l’expression XPath 

client[nom=’Sylvain’] nous donne les éléments « client » pour lesquels le contenu 

du sous-élément « nom » est « Sylvain ». 

« xsl:for-each » : Lorsqu’il y a un ensemble de résultats, on itère sur la séquence de 

tous les éléments « client » ayant comme nom « Sylvain » avec l’expression XPath 

//client[nom=’Sylvain’]. Par exemple, l’instruction « , » donnera une liste, séparée par des virgules, 

du contenu textuel de tous les éléments « client » contenus dans l’élément courant. 

Fonction XPath current() : Représente toujours l’élément XSLT courant. L’expression 

« //client[nom=current()/nom] » donne tous les éléments « client » qui ont un 

attribut « nom » dont la valeur est la même que l’élément courant. Par contre, l’expression 

« //client[nom=./nom] » a la même signification que « //client[nom] », c’est-àdire 

qu’on sélectionne tous les éléments « client » contenus dans l’élément courant ou 

ses sous-éléments qui ont un attribut « nom ». 

Fonctions arithmétiques XPath : On peut faire des calculs simples en XPath comme 

dans les expressions « 1+1 », « 2*1 » et « 5 div 2 ». On aussi les fonctions « floor », 

« ceiling » et « round ». 

CC BY-NC-SA

Bibliographie 

[1] « IT 4247 XML fundamentals (course outline) ». 

[2] « Xml, xsl and web applications » – http://www.infosys.tuwien.ac.at/teaching/ 

courses/XML/. 

[3] « Draft standard for learning object metadata » – Tech. Report 1484.12.1-2002, 

IEEE, July 2002. 

[4] « Dublin core metadata element set, version 1.1: Reference description » – Tech. 

report, DCMI, 2003. 

[5] « W3 schools » – http://www.w3schools.com/, 2004. 

[6] A. B. ET AL. – XML: la synthèse, Dunod, 2003. 

[7] H. A. ET AL. – Building corporate portals using XML, McGraw Hill, 1999. 

[8] J. P. ET AL. – Professional XML, Wrox, 2001. 

[9] L. BIRKEDAL – « Advanced XML / data on the web (course outline) », http: 

//www.itu.dk/~birkedal/teaching/data-on-the-web-Fall-2002/. 

[10] H. BOLEY – « Auszug vorlesungsverzeichnis informatik », http://www.dfki. 

uni-kl.de/~boley/lexml/. 

[11] H. BOLEY et B. SPENCER – « CS 6905 semantic web techniques (course outline) 

», http://www.cs.unb.ca/~bspencer/cs6905swt/syllabus.html. 

[12] H. BOLEY, S. TABET et G. WAGNER – « Design Rationale of RuleML: A Markup 

Language for Semantic Web Rules », Proc. Semantic Web Working Symposium 

(SWWS’01), Stanford University, July/August 2001, p. 381–401. 

[13] M. DEAN et G. SCHREIBER – « OWL Web Ontology Language – Reference », 

W3C Candidate Recommendation, W3C, August 2003. 

[14] S. DOWNES – « Topic representation and learning object metadata », http://www. 

downes.ca/post/99, 2002. 

[15] E. R. HAROLD – XML bible, John Wiley & Sons, 2001. 

[16] E. R. HAROLD et W. SCOTT – XML in a nutshell, O’Reilly, 2003. 

[17] J. HJELM – Creating the semantic web with RDF: Professional developer’s guide, 

John Wiley & Sons, 2001. 

399

Bibliographie 400 

[18] J. HUNT, D. DAY, E. HENNUM, M. PRIESTLEY et D. A. SCHELL – « Why use 

DITA to produce HTML deliverables », http://www-106.ibm.com/developerworks/ 

xml/library/x-dita6/index.html. 

[19] S. LUCAS – « CC432-G-SP: XML and related technologies (course outline) », 

http://www2.essex.ac.uk/courses/result.aspcoursecode=CC432&level=G&period= 

SP&yearofcourse=03. 

[20] B. MCLAUGHLIN – Java & XML, O’Reilly, 2001. 

[21] E. T. RAY – Learning XML, O’Reilly, 2001. 

[22] K. M. TADIOU – « IFT-62399 web sémantique ». 

[23] E. TITTEL – XML, Schaum’s, Dunod, 2003. 

CC BY-NC-SA

Manuel INF 6450 (complet) - Téluq

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?