Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Books on Demand
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Französisch
Cet ouvrage s’inspire de mon expérience issue de plusieurs années d’enseignement et de formation en informatique. J’ai souhaité faire bénéficier de cette expérience tous ceux qui, à des titres divers, peuvent être amenés à étudier XML ou à réaliser des développements qui impliquent son utilisation. XML est une famille de langages partageant des caractéristiques communes et qui sont dédiés à une multitude d’usages divers. Les facilités d’écriture de ce format, les possibilités de traitement des données qu’il offre et sa souplesse d’utilisation, en font un format extrêmement bien adapté aux échanges de données entre applications aussi bien qu’à leur simple stockage. C’est donc tout naturellement que son usage s’est largement répandu au point d’être aujourd’hui incontournable. Cet ouvrage propose donc d’en aborder l’apprentissage de manière progressive et pédagogique, et de pouvoir en apprécier son utilisation en programmation, notamment avec C#5, WPF et LINQ. Le chapitre 1 expose les bases du langage XML. Le chapitre 2 traite du langage XPath pour l’élaboration et l’évaluation d’expression. Le chapitre 3 traite de la réalisation des feuilles de transformations XSLT nécessaires à l’élaboration de fichier HTML pour visualiser des données XML. Le chapitre 4 traite de la réalisation des feuilles de transformation XSL-FO et de leurs usages dans la réalisation de PDF imprimables avec Apache FOP. Le chapitre 5 traite de la réalisation des DTD. Le chapitre 6 traite d’un langage de définition de contenu qu’est le schéma XML. Le chapitre 7 traite des manipulations à connaître pour un document XML avec le DOM. Le chapitre 8 traite des manipulations de lecture et d’écrire des données XML. Le chapitre 9 traite de la mise en pratique de l’évaluation des expressions XPath par programmation. Le chapitre 10 traite de la pratique de la validation de document XML par la DTD et par le schéma XML. Le chapitre 11 traite de la pratique de la transformation XSLT par programmation. Le chapitre 12 expose les différents principes pour le chargement des fichiers XML avec LINQ To XML. Le chapitre 13 expose tout ce que LINQ To XML permet pour la création des arborescences XML. Le chapitre 14 expose tout ce que LINQ To XML permet pour se déplacer au sein d’une arborescence XML. Le chapitre 15 expose tout ce que LINQ To XML permet pour procéder à la modification des données XML par un ensemble de propriétés et de méthodes spécifiques.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 614
Veröffentlichungsjahr: 2015
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Table des matières
Le code source de programmation est téléchargeable gratuitement à l’adresse web http://www.reypatrice.fr
Avant-propos
Partie 1 : Tout savoir sur le langage XML
1 - Les principes de XML
La genèse de XML
Pourquoi XML ?
Installer un éditeur de XML
La conception d’un document XML
4.1 - Le prologue
4.2 - Les commentaires
4.3 - L’arborescence du document
4.4 - Les nœuds de type élément
4.5 - Les nœuds de type attribut
4.6 - Les entités prédéfinies
4.7 - Les sections CDATA et PCDATA
4.8 - L’encodage de documents
Règles d’écriture et document bien formé
Mise en forme à l’aide de CSS
2 - Le langage d’expression XPath
Evaluer une expression XPath avec un éditeur XML
Les chemins de localisation
2.1 - Les expressions basiques
2.2 - Les expressions avancées
2.3 - Les noms d’axe
Les opérateurs XPath
Les fonctions XPath
4.1 - Les fonctions de nœuds
4.2 - Les fonctions booléennes
4.3 - Les fonctions sur les chaînes de caractères
4.4 - Les fonctions numériques
3 - Le langage de transformation XSLT
Ma première transformation XSLT
1.1 - Mise en place d’une transformation simple
1.2 - Les premières instructions
Les modèles et leurs applications
2.1 - Les éléments xsl:template et xsl:apply-templates
2.2 - L’élément xsl:text
2.3 - Les modèles internes
Les instructions XSLT
3.1 - Créer des éléments et des attributs
3.2 - Les tests conditionnels et les tris
3.3 - Les instructions courantes
Les instructions avancées
4 - Le langage de transformation XSL-FO
Installation et utilisation de Apache FOP
Dispositif de mise en forme d’une page
Mise en forme du contenu
Les fonctionnalités avancées
4.1 - Les listes
4.2 - Les tableaux
4.3 - Les hyperliens
4.4 - Les notes de bas de page
4.5 - Les ressources externes
4.6 - Le positionnement absolu
4.7 - La numérotation des pages
Exemple d’application avec OXYGEN Editor 15
5.1 - Création d’un document XML
5.2 - Création d’un document XSLT
5.3 - Création d’un document XSL-FO et d’un PDF
5 - La déclaration de type de document (DTD)
Associer une DTD à un document XML
Le contenu d’une DTD
2.1 - Les règles sur les éléments
2.2 - Les règles sur les attributs
2.3 - Les DTD internes et externes
Déclaration et utilisation des entités
3.1 - Les entités générales
3.2 - Les entités paramètres
6 - Le schéma XML
Comparaison entre la DTD et le schéma XML
Associer un schéma XML à un document XML
Déclarer les éléments et les attributs
Les types simples de données
4.1 - Les types simples définis dans la recommandation
4.2 - Les types simples définis par dérivation
Les types complexes de données
Modularisation des schémas
Documentation des schémas
Partie 2 : Programmation XML avec C#5, WPF et LINQ
7 - Manipuler un document XML avec DOM
La classe XmlDocument
Charger un document XML
Visualiser une arborescence XML
Rechercher des nœuds XML
Recherche dans un document XML validé par une DTD
Recherche avec une requête XPath
Modifier des nœuds XML
Les espaces de noms
8 - Lire et écrire des documents XML
Utilisation de XmlTextReader et XmlTextWriter
Lire un document XML avec XmlTextReader
Représenter l’arborescence XML par un TreeView
Se déplacer dans l’arborescence XML
Ecrire un document XML avec XmlTextWriter
5.1 - Utiliser SQL SERVER 2012 Express
5.2 - Exporter des données au format XML
Traiter les données non textuelles
9 - Accéder aux données XML avec XPath
Naviguer dans un document avec XPathNavigator
Evaluer une expression XPath
Obtenir le premier noeud d’une expression évaluée
Editer, modifier et sauvegarder
10 - Valider un document XML
Outil de définition de schéma XML
Générer un schéma XML par programmation
La validation d’un document XML
3.1 - Valider un document XML doté d’une DTD
3.2 - Valider un document XML doté d’un schéma
11 - Les transformations avec XSLT
La classe XslCompiledTransform
Réaliser une transformation XSLT
Passer des paramètres à une transformation XSLT
Le compilateur XSLT de Visual Studio 2013
12 - Chargement XML avec LINQ
Les atouts de l’API LINQ To XML
Le modèle objet LINQ To XML
Charger un document XML externe
Charger une chaîne de caractères XML
Charger avec un objet XmlReader
13 - La création d’arbres XML avec LINQ
Création des éléments avec XElement
Création des attributs avec XAttribute
Création des commentaires avec XComment
Création des conteneurs avec XContainer
Création de déclaration XML avec XDeclaration
Création de types de documents avec XDocumentType
Création des documents avec XDocument
Création des noms avec XName
Création des espaces de noms avec XNamespace
Création des instructions de traitement
Création des éléments XStreamingElement
Création des textes avec XText et XCData
Sauvegarder un document XML
14 - Se déplacer dans l’arborescence XML avec LINQ
Parcourir une arborescence XML
Se déplacer dans une arborescence
2.1 - Méthodes Elements et Element
2.2 - Propriétés NextNode, PreviousNode et Parent
2.3 - Méthodes Ancestors et AncestorsAndSelf
2.4 - Méthodes Descendants et DescendantsAndSelf
2.5 - Méthodes ElementsAfterSelf et ElementsBeforeSelf
2.6 - Méthodes NodesAfterSelf et NodesBeforeSelf
2.7 - Méthodes Nodes et Attributes
15 - La gestion des données XML avec LINQ
Modifier les données
1.1 - Méthodes Add et AddFirst
1.2 - Méthodes AddBeforeSelf et AddAfterSelf
1.3 - Méthodes Remove et RemoveAll
1.4 - Modification de la propriété Value
1.5 - Méthode ReplaceAll
1.6 - Méthode SetElementValue
La gestion des attributs
La gestion des annotations
Les événements XML
16 - Requêtes et méthodes d’extensions avec LINQ
Les expressions de requête LINQ
1.1 - Utilisation du contrôle ListView
1.2 - Expression d’une requête LINQ
1.3 - La clause WHERE
1.4 - Les clauses LET et ORDERBY
Les méthodes d’extensions
2.1 - L’extension Ancestors
2.2 - L’extension AncestorsAndSelf
2.3 - L’extension Attributes
2.4 - L’extension DescendantNodes
2.5 - L’extension DescendantNodesAndSelf
2.6 - L’extension Descendants
2.7 - L’extension DescendantsAndSelf
2.8 - L’extension Elements
2.9 - L’extension Nodes
2.10 - L’extension Remove
Réaliser une requête complexe
17 - Exemples pratiques avec LINQ To XML
Encodage et décodage des images
1.1 - Réalisation d’une fiche de cinéma
1.2 - Générer un fichier d’échange XML
1.3 - Décodage et génération d’une image
Sauvegarder et charger une scène graphique 2D
2.1 - Générer et ajouter des objets 2D à la scène
2.2 - Dessiner un quadrillage sur un Canvas
2.3 - Sauvegarder les données graphiques avec XML
2.4 - Reconstruction de la scène 2D
Fichier d’échange XML pour les modèles 3D
Représentation graphique de données XML
4.1 - Charger une ressource incorporée
4.2 - Définir une représentation graphique
Arborescence de données hiérarchiques XML
5.1 - Les contrôles TreeView et TreeViewItem
5.2 - Représentation classique des données
5.3 - Représentation stylisée des données
5.4 - La prise en charge des commentaires XML
Index
Avant-propos
Cet ouvrage s’inspire de mon expérience issue de plusieurs années d’enseignement et de formation en informatique. J’ai souhaité faire bénéficier de cette expérience tous ceux qui, à des titres divers, peuvent être amenés à étudier XML ou à réaliser des développements qui impliquent son utilisation.
XML est une famille de langages partageant des caractéristiques communes et qui sont dédiés à une multitude d’usages divers. Les facilités d’écriture de ce format, les possibilités de traitement des données qu’il offre et sa souplesse d’utilisation, en font un format extrêmement bien adapté aux échanges de données entre applications aussi bien qu’à leur simple stockage. C’est donc tout naturellement que son usage s’est largement répandu au point d’être aujourd’hui incontournable. Cet ouvrage propose donc d’en aborder l’apprentissage de manière progressive et pédagogique, et de pouvoir en apprécier son utilisation en programmation, notamment avec C#5, WPF et LINQ.
Le contenu du livre
Les différents chapitres permettent d’apprendre à concevoir des documents XML, à valider des documents XML, à générer des documents XML au travers des langages de transformation et en fonction d’expression XPath, et à utiliser en pratique ces documents XML dans des applications écrites en C#5 à l’aide de WPF et LINQ au sein de projets réalisés avec l’environnement de développement intégré Visual Studio 2013. Les chapitres abordent les points suivants:
le
chapitre 1
expose les bases du langage XML par la structuration de l’information, les règles d’écriture, la notion de document bien formé et valide, et la mise en forme simple à l’aide du langage CSS.
le
chapitre 2
traite du langage XPath pour l’élaboration et l’évaluation d’expression sur un document XML, au travers de sa syntaxe, de ses opérateurs et de ses fonctions.
le
chapitre 3
traite de la réalisation des feuilles de transformations XSLT nécessaires à l’élaboration de fichier HTML pour visualiser des données XML; il sera abordé l’utilisation des modèles, l’utilisation des instructions courantes et avancées, la création des éléments, les tests conditionnels et les tris alphanumériques.
le
chapitre 4
traite de la réalisation des feuilles de transformation XSL-FO, et de leurs usages dans la réalisation de PDF imprimables avec Apache FOP; un cas pratique complet de toute la chaîne de transformation sera abordé avec l’utilisation d’un logiciel commercial qu’est OXYGEN Editor 15.
le
chapitre 5
traite de la conception et de la réalisation des DTD (définition de type de document); les DTD évitent les dysfonctionnements dans la conception des documents XML; nous y verrons comment associer une DTD à un document XML, quelle est la syntaxe de ses règles, et comment valider un document XML.
le
chapitre 6
traite d’un autre langage de définition de contenu qu’est le schéma XML (XML Schema en anglais); le schéma XML est de loin le plus utilisé; nous y verrons comment déclarer des éléments et des attributs, quels sont les types simples définis dans la recommandation du W3C et ceux définis par dérivation, comment concevoir les types complexes de données, et comment modulariser et documenter le schéma XML.
le
chapitre 7
traite des manipulations à connaître pour un document XML avec le modèle objet de document (DOM); on y verra notamment comment charger un document XML pour visualiser son contenu, comment effectuer des recherches de nœuds, comment effectuer des modifications de nœuds, et comment visualiser l’arborescence d’un document XML dans un contrôle dédié
TreeView.
le
chapitre 8
traite des manipulations de lecture et d’écrire avec les classes
XmlTextReader
et
XmlTextWriter;
il sera abordé les déplacements dans l’arborescence XML avec
XmlTextReader,
et l’écriture des données XML avec
XmlTextWriter.
le
chapitre 9
traite de la mise en pratique de l’évaluation des expressions XPath avec notamment comment élaborer une requête pour évaluer une expression XPath, comment lire les données retournées par la requête, et comment les modifier et les sauvegarder.
le
chapitre 10
traite de la pratique de la validation de document XML par la DTD et par le schéma XML; il sera vu notamment comment générer un schéma XML par programmation grâce à des classes spécifiques du
framework .NET.
le
chapitre 11
traite de la pratique de la transformation XSLT par programmation; il sera vu notamment comment effectuer une transformation XSLT par programmation pour obtenir un document HTML, ainsi que le cas avec le passage de paramètres.
le
chapitre 12
expose les différents principes pour le chargement des fichiers XML destinés à être exploités avec la technologie LINQ To XML.
le
chapitre 13
expose, en théorie et en pratique, tout ce que LINQ To XML permet pour la création des arborescences XML (document XML avec sa déclaration, avec les commentaires, avec les éléments dotés d’attributs et de contenu textuel, des balises CDATA, etc.) et pour la sauvegarde de ces arborescences.
le
chapitre 14
expose, en théorie et en pratique, tout ce que LINQ To XML permet pour se déplacer au sein d’une arborescence XML au travers d’un ensemble de propriétés et de méthodes spécifiques.
le
chapitre 15
expose, en théorie et en pratique, tout ce que LINQ To XML permet pour procéder à la modification des données XML par un ensemble de propriétés et de méthodes spécifiques; la gestion des données XML tient compte de la gestion des nœuds, de la gestion des attributs, de la gestion des annotations et de la gestion des événements liés aux modifications.
le
chapitre 16
expose, en théorie et en pratique, tout ce que LINQ To XML permet pour effectuer des requêtes LINQ par l’intermédiaire d’expressions composées de différentes clauses; il sera abordé au cours de cette étape de l’utilisation des méthodes d’extensions qui permettent d’effectuer des modifications précises sur une collection de nœuds.
le
chapitre 17
est destiné à vous montrer 5 applications complètes et détaillées de l’utilisation de LINQ To XML dans le domaine professionnel; la première application consiste à vous montrer comment on utilise XML pour sauvegarder les images au format XML par une lecture de ses pixels (
figure A1
au repère 1); puis avec un fichier d’échange sauvegardé, on charge les données et on regénère l’image initiale; la seconde application consiste à vous montrer comment on utilise XML pour sauvegarder et pour charger une scène graphique 2D (
figure A1
au repère 2); la troisième application consiste à vous montrer comment on utilise XML pour sauvegarder et pour charger une scène graphique 3D composée de modèles 3D (
figure A2
au repère 1); la quatrième application consiste à vous montrer comment on représente des données XML par des composants dédiés d’un point de vue purement graphique (
figure A2
au repère 2); la cinquième application consiste à vous montrer comment on réalise des arborescenses de données hiérarchiques XML avec des contrôles
TreeView
pour la présentation des données XML (
figure A3
).
Figure A1
Figure A2
Figure A3
Les logiciels requis pour le développement
Pour réaliser plus facilement des programmes en C# et XAML, il est préférable d’utiliser un environnement de développement intégré ou IDE (Integrated Development Environment).
Cet IDE permet de développer, de compiler et d’exécuter un programme dans un langage donné qui sera, dans ce livre, le C# (se prononce «Csharp») dans sa version 5. Microsoft propose comme IDE une version complète et gratuite avec soit Visual Studio 2013 Community (figure A4 au repère 1), soit Visual Studio 2015 Community (figure A4 au repère 2). Les deux versions sont téléchargeables à l’adresse web https://www.visualstudio.com/downloads/download-visual-studio-vs.
Puissante interface IDE garantissant la production d’un code de qualité, Visual Studio intègre de nouvelles fonctionnalités qui simplifient le processus de développement d’application, de la conception au déploiement.
Figure A4
Les liens de téléchargement
Tout le code source de cet ouvrage pourra être téléchargé gratuitement en se rendant sur la page web du livre à l’adresse web suivante:
http://www.reypatrice.fr
Vous trouverez dans l’arborescence des fichiers du projet, un dossier pour chacun des chapitres. Chaque dossier contient tous les éléments nécessaires de programmation qui sont expliqués dans le livre. De cette façon, vous serez capable de suivre et de programmer assez rapidement et assez facilement. C’est une démarche volontaire, dans un but pédagogique, pour progresser rapidement.
Bonne lecture à tous.
Les principes de XML
1
XML est un langage de description de document. C’est un langage qui va contenir à la fois les données du contenu mais aussi une qualification représentée par les métadonnées sur ce contenu. C‘est un langage qui va donc décrire un document ou des données en mélangeant les valeurs et la qualification de ces valeurs. XML contient beaucoup de richesses. Nous verrons comment structurer un document XML, quelles sont les contraintes qui font qu’un document XML est bien formé et reconnaissable comme un vrai document XML, qu’est-ce que l’on met à l’intérieur d’un document XML, quels sont les types de données, comment est-ce que l’on va représenter les données plus complexes et les caractères spéciaux, etc.
Nous verrons comment manipuler le document XML car autour de XML, beaucoup de technologies se sont développées, technologies qui permettent de qualifier les métadonnées (avec les espaces de noms par exemple), technologies qui permettent de valider des structures par rapport à des règles spécifiques (d’une entreprise par exemple) pour des types de données spécifiques à l’aide de ce que l’on appelle un schéma.
Nous verrons aussi que l’on peut parcourir le chemin à l’intérieur de XML pour aller en extraire des informations directement avec un langage qui s’appelle XPATH. Nous verrons qu’à l’aide de ce chemin, nous pouvons extraire des informations mais également appliquer des feuilles de style de façon à faire des transformations pour extraire un fragment et l’afficher dans un autre format comme du HTML par exemple.
1 - La genèse de XML
La question que tout le monde se pose est bien entendu qu’est-ce que XML ? Est-ce que XML est un langage? Oui c’est un langage mais pas au sens où on l’entend en terme de langage de programmation. Ce n’est pas un langage qui fait quelque chose, qui effectue des actions, c’est un langage qui décrit un document. Il s’agit en fait d’un langage de balisage de document, dérivé d’un langage préliminaire qui s’appelle le SGML.
A la fin des années 1970, la société IBM a été à l’origine de la création d’un langage de description de données, fondé sur des balises. Ce langage nommé SGML (Standard Generalized Markup Language) fut publié comme norme ISO 8879:1986 en 1986. Ce langage permettait de décrire la structure d’un document indépendamment de sa visualisation, ou plus généralement de son interprétation par une application tierce. Il fallait en effet fournir:
une définition de type de document (DTD) afin de définir les éléments autorisés dans le document à décrire.
une instance du document c’est-à-dire le texte réel du document comprenant les éléments SGML définis dans la DTD et qui identifient les diverses parties du texte; même si une instance de document peut partager une DTD avec d’autres documents, elle ne peut se conformer qu’à une seule DTD.
la synthèse du document qui sert à préciser les principaux aspects de l’application SGML; c’est à ce niveau que sont déterminées les options et que sont précisés le jeu de caractères utilisé ainsi que les autres fonctions similaires.
SGML est un puissant langage de description mais il est très complexe, notamment à cause des règles concernant les fermetures codées, les fermetures implicites, etc. Lors des travaux de développement du World Wide Web, il fut nécessaire de simplifier le SGML pour le rendre utilisable facilement pour la création de pages web. Il en résulta HTML, une application de SGML limitée à un contexte particulier. Il faudra attendre la version HTML 4.0 publiée par le consortium W3C, en charge de la définition des standards de l’Internet, en 1997 pour avoir un format HTML dans lequel on ait la séparation du fond et de la forme par l’emploi des feuilles de style à l’aide du langage CSS.
Le HTML est une forme de SGML qui décrit le formatage d’un document. L’interprétation des balises HTML va permettre de réaliser des tableaux, des listes, des paragraphes, etc. Le navigateur va lire la source HTML et va produire un document formaté en fonction des balises trouvées et interprétées. Le navigateur apparait comme un simple outil consistant à interpréter le langage HTML et à le reformater pour l’utilisateur sur un ordinateur client.
Comme HTML restait évidemment un langage étroitement lié à la publication de contenu pour le web et non personnalisable, il fut décidé de tirer parti à la fois de la souplesse de SGML et de la simplicité d’utilisation de HTML. Ce fut chose faite avec la publication en février 1998 de la première version de la recommandation XML 1.0.
XML, qui est dérivé de SGML, est l’héritier attendu de SGML et de HTML. XML est une simplification de SGML avec un certain nombre de concepts SGML conservés et parfois quelques aménagements. Avec XML, il est maintenant facultatif de fournir une DTD tout en gardant la possibilité d’en créer une, voire d’utiliser un autre format comme XML Schema pour définir les éléments utilisables dans le document XML. La séparation du fond et de la forme est stricte, rendant possible le traitement d’un même document XML par diverses applications en vue d’utilisations différentes. En revanche, XML présente quelques nouveautés:
une syntaxe plus stricte qu’en SGML, ce qui réduit les contraintes sur les applications de traitement.
une gestion de l’encodage qui autorise l’utilisation des caractères spéciaux.
un langage de transformation XSL
(eXtensible Stylesheet Language),
qui est lui-même un format XML, qui permet d’automatiser le traitement d’un document XML donné.
un langage de description et de définition,
XML Schema,
qui est lui aussi un document XML, qui étend les possibilités des DTD.
XML va décrire non pas le formatage mais le type de contenu qui va être proposé dans le document. Il s’agit donc d’une description sémantique du contenu. XML va servir à qualifier les différentes données, les différents éléments qui sont dans un document. C’est donc très intéressant car cela va permettre de pouvoir échanger un document non seulement avec son contenu mais aussi avec la description intégrée de son contenu. XML permet de séparer nettement le fond de la forme d’un document. Il s’avère souvent nécessaire de transformer le fichier brut par exemple pour permettre son affichage ou son impression pour l’œil humain, ou bien son traitement par une application donnée. Cela entraîne la nécessité de faire intervenir au moins deux fichiers: le fichier XML proprement dit qui contiendra les données à mettre en forme, et le fichier qui permettra sa transformation et son adaptation au média de sortie sélectionné. Dans le contexte d’une production de masse, l’ensemble de la chaîne est constitué de trois à quatre maillons:
la définition des éléments utilisables dans le document XML.
le document XML lui-même.
les outils de transformation du document.
dans le contexte d’une page web, une feuille de style CSS pour la mise en forme finale.
2 - Pourquoi XML ?
La question que l’on peut se poser c’est pourquoi utiliser XML, à quoi cela peut-il bien servir? XML a un certain nombre d’avantages. Vous pouvez construire des documents, des choses statiques en pur texte, qui contiennent non seulement un contenu qui peut être relativement riche, long et important, mais également la description de ce contenu. On peut donc ajouter la sémantique à l’intérieur de ce document. Cela peut aboutir à des choses intéressantes comme ce que l’on appelle le web sémantique, c’est-à-dire la capacité à travers des pages web non seulement de formater mais aussi de qualifier la donnée. Cela permet à des moteurs de recherche automatisés de mieux cibler le contenu des pages web, et par conséquent de faire des recherches plus précises. En mélangeant le formatage et la sémantique, on enrichit la donnée qui se trouve sur Internet.
Il s’agit de donner du sens à des documents ou à de la donnée, et il s’agit aussi de pouvoir se les échanger. L’avantage de XML c’est qu’il fonctionne avec du texte. Le texte en informatique est reconnu par tous les systèmes et par tous les langages. Si j’échange un document qui est purement en texte, je vais être beaucoup plus portable, beaucoup plus universel que si j’échange un document de type binaire comme un fichier Word ou un fichier PDF. Le texte est alors idéal. Je vais pouvoir échanger en pur texte des données qui sont qualifiées et qui sont aussi hiérarchiques parce qu’un élément que l’on appelle un nœud, va pouvoir contenir des sous-éléments (des sous-nœuds). La hiérarchie permet d’exprimer quelque chose de complexe avec des données structurées.
Avec XML, on est plus dans une approche où l’on va construire des documents qui sont plutôt des données que l’on va manipuler par des programmes, et que l’on va échanger. On va pouvoir exprimer des données riches, qui vont être bien structurées ou semi-structurées, et les traiter automatiquement par un certain nombre de systèmes car le langage XML va être très facile à parser. Parser un document XML (parsing en anglais) consiste à interpréter automatiquement par des bibliothèques le contenu XML. Ces bibliothèques d’interprétation sont présentes dans tous les langages de programmation. De plus, il y a beaucoup de techniques qui tournent autour de XML, notamment des techniques qui vont permettre, outre le fait de parser, de reconnaître les différents éléments mais aussi de les transformer, de prendre un document et d’utiliser un langage de description, de transformation qui va permettre d’élaborer automatiquement un nouveau document à partir du document originel (il s’agit de XSLT pour le langage de transformation de XML). On va pouvoir également faire des recherches automatiquement à l’intérieur du document ou accéder à certains nœuds de ce document, à l’aide d’un langage qui s’appelle XPATH, qui permet de se déplacer, de trouver des chemins à l’intérieur du document. Et une extension encore plus puissante, qui s’appelle XQUERY, permet de faire des recherches à l’intérieur du document XML.
On va pouvoir indiquer aussi qu’un document a une certaine structure obligatoire à l’aide d’un langage de description de structure de document qui s’appelle le schéma XML (XML Schema). Si j’échange des données entre différents systèmes à l’aide du schéma, je vais pouvoir indiquer que le document XML doit contenir un certain nombre de balises, avoir une certaine structure bien définie de façon à s’assurer que le document est valide du point de vue de cette structure. Comme vous le voyez, nous avons non seulement un langage de description du document, mais aussi des outils qui s’ajoutent au XML pour en assurer les transformations, les recherches et la validation. Il s’agit d’un ensemble bien construit d’outils qui vont nous permettre de faire des échanges de données solides, multiplateformes, très souples et extensibles à l’infini.
3 - Installer un éditeur de XML
Ecrire du code XML peut se faire avec un simple éditeur de texte. Mais, comme le XML possède une syntaxe stricte de balisage, il est alors plus facile d’utiliser des éditeurs dédiés de XML, permettant de réduire considérablement le code à écrire. Par exemple, lorsque vous écrivez une balise ouvrante, l’éditeur complète automatiquement en écrivant la balise fermante. C’est une aide très utile à l’écriture. De nombreux logiciels commerciaux existent, ils sont en général très complet. Le plus connu et le plus complet est OXYGEN XML EDITOR. Il existe aussi des logiciels plus simples et open source, très facile à l’utilisation notamment pour l’apprentissage du XML. Ici nous utiliserons le logiciel XML Copy Editor,qui est un logiciel open source très simple et très pratique dans le cadre de l’apprentissage de XML, doté d’une translation linguistique en français. Vous pouvez le télécharger en vous rendant sur la page web suivante (figure 1.1): http://sourceforge.net/projects/xml-copy-editor. L’installation du logiciel s’effectue en quelques minutes en utilisant les réglages proposés par défaut.
FIGURE 1.1
4 - La conception d’un document XML
Supposons que nous ayons une bibliothèque de livres (figure 1.2) composée de 4 allées, et chacune de ces 4 allées contient un ensemble de 4 armoires à livres. Une armoire à livres contient un ensemble d’étagères (par exemple une dizaine).
FIGURE 1.2
Nous allons créer un document XML pour exprimer notre bibliothèque avec son contenu. Le but est d’avoir une énumération des livres et de pouvoir les localiser en fonction des allées, des armoires et des étagères. La figure 1.3 visualise un exemple de document XML tel que l’on pourrait le réaliser avec XML Copy Editor. Ce document XML, intitulé exemple_biblio.xml, se trouve dans le dossier chapitre_01 du code source de programmation. Vous pouvez télécharger gratuitement ce code source en vous rendant sur la page web dédiée à ce livre (la fiche du livre se trouve sur le site web à l’adresse http://www.reypatrice.fr).
FIGURE 1.3
Le document exemple_biblio.xml est un fichier dont les données sont structurées à l’aide de "briques" que nous allons passer en revue.
4.1 - Le prologue
FIGURE 1.4
L’attribut encoding précise l’encodage de caractères utilisé pour réaliser le document XML. Il s’agit d’une information importante qui est transmise à l’application chargée du traitement, et qui lui indique dans quel type de codage le fichier a été enregistré. Autrement dit, cet attribut encoding indique comment physiquement sur le disque dur une suite de bits est associée à un caractère ou un autre. L’encodage utilisé par défaut est l’UTF-8. Rien n’empêche d’utiliser un autre encodage (comme ISO-8859-1, ASCII, etc.) du moment que cela est précisé dans l’attribut encoding et que l’enregistrement du fichier est bien effectué avec cet encodage spécifié.
Une dernière information est précisée par l’attribut standalone. Cet attribut standalone est facultatif dans l’écriture du prologue. Sa valeur par défaut est yes. Il indique si le document XML dépend d’un autre fichier pour la définition de sa syntaxe, ou bien s’il se suffit à lui-même. La valeur yes par défaut indique que le document tient "debout tout seul", autrement dit qu’il n’est pas nécessaire de lui adjoindre un autre document pour vérifier sa syntaxe. La seconde valeur possible pour cet attribut est no, signifiant que le document a besoin d’un autre fichier sous forme d’une DTD (nous verrons dans un autre chapitre comment s’articule les définitions de type de document avec la DTD). A noter une chose importante: dans un prologue, les attributs doivent être impérativement utilisés dans l’ordre version, encoding et standalone.
4.2 - Les commentaires
Les commentaires sont conformes à la norme SGML. Un commentaire commence par la chaîne de caractères <!-- et se termine par la chaîne --> (figure 1.5). Du fait de la composition du balisage d’un commentaire, un commentaire ne peut pas contenir la chaîne "--" car c’est une chaîne réservée. Un nœud commentaire sert bien évidemment à ajouter un commentaire au document XML. Les commentaires n’ont pas vocation à être interprétés par l’application chargée du traitement du document. Ils peuvent par conséquent servir à insérer une documentation succincte dans le corps du document XML. A noter que l’on retrouve cette syntaxe de commentaires dans un document HTML. Ils sont ignorés lors de leur affichage par le navigateur.
FIGURE 1.5
4.3 - L’arborescence du document
La hiérarchisation des données a une traduction physique dans la structure du document XML lui-même. On parle de l’arborescence du document en faisant référence à cette structure pyramidale. Cette arborescence est constituée de nœuds. L’arborescence du document représente donc la structure hiérarchique des nœuds. La plupart des nœuds d’un document ont un nœud parent, parfois des nœuds frères, parfois aussi des nœuds enfants. Un unique nœud de l’arborescence ne possède pas de parent, c’est l’élément racine. De lui seul dépendent tous les autres nœuds à des niveaux divers et variés de l’arborescence. La figure 1.6 schématise un exemple d’arborescence de document XML. Le nœud racine possède trois enfants qui sont le nœud 1, le nœud 2 et le nœud 3. Le nœud 2 possède deux enfants (le nœud 2.1 et le nœud 2.2), et le nœud 3 possède trois enfants (le nœud 3.1, le nœud 3.2 et le nœud 3.3). Les nœuds 1, 2 et 3 sont des nœuds frères, et ils possèdent le même parent qui est le nœud racine. Les nœuds 2.1 et 2.2 sont des nœuds frères et ils possèdent comme nœud parent le nœud 2.
FIGURE 1.6
En tenant compte de notre document exemple_biblio.xml, on peut établir une arborescence du document en fonction des nœuds qu’il contient (figure 1.7). Nous avons le nœud racine qualifié par l’intitulé bibliotheque. Cette racine possède des enfants qualifiés par des nœuds intitulés livre. Un nœud livre possède des enfants qualifiés par une variété de nœuds intitulés titre, auteur, nb_tome, stockage et resume.
FIGURE 1.7
4.4 - Les nœuds de type élément
La structure d’un document XML est surtout visible dans celle de ces éléments. Il s’agit des étiquettes associées aux données afin de les caractériser. Dans notre exemple, les éléments portent les noms de livre, titre, auteur, nb_tome, stockage et resume. Ces éléments possèdent un certain nombre de caractéristiques (figure 1.8):
un élément s’ouvre et se ferme par une balise; le nom de l’élément est repris dans la balise ouvrante et dans la balise fermante; par exemple, le nœud
titre
commence par la balise ouvrante
<titre>
et se termine par la balise fermante
</titre>.
certains éléments ne contiennent pas d’éléments fils; la balise fermante est ainsi intégrée à la balise ouvrante qui est alors qualifiée de balise autofermante; c’est le cas dans notre exemple avec l’élément
stockage;
le nœud
stockage
s’écrit alors
<stockage />
(la balise qui signale le début de l’élément se termine avec un caractère slash, on parle alors d’élement vide).
FIGURE 1.8
4.5 - Les nœuds de type attribut
4.6 - Les entités prédéfinies
Par définition, dans le cas général, une entité est une chaîne de caractères commençant par le caractère "&" (dit "et commercial" ou esperluette) et se terminant par le caractère point-virgule Une entitée est déclarée dans une définition de type de document (ou DTD pour Document Type Definition). Les entités sont des composants un peu particuliers dans les documents XML. Elles s’apparentent à des macros et, lors du traitement du document XML par une application dédiée, elles sont remplacées par la chaîne de caractères qu’elles représentent. Certaines entités ont un sens particulier en XML, et se nomment les entités prédéfinies. Par exemple, les caractères chevron ouvrant ("<") et chevron fermant (">") sont des caractères employés pour signaler le début et la fin d’une balise. Or, si pour la valeur d’un élément, on a besoin d’employer le caractère chevron ouvrant et/ou chevron fermant, il faut pouvoir signaler que c’est un caractère pour son interprétation par l’application. Cela se fait donc en remplaçant le caractère chevron par une entité prédéfinie indiquant qu’il s’agit du caractère chevron lors de l’interprétation. Ces entités prédéfinies, que l’on appelle également séquences d’échappement, ne nécessitent pas de déclaration dans une DTD. Le tableau ci-dessous affiche les caractères qui sont représentés par des entités prédéfinies.
Dans l’exemple suivant (figure 1.9), nous avons l’élément expression_verbale qui a pour valeur trois est supérieur ou égal à deux, et l’élément expression_ mathematique qui a pour valeur 3 >= 2. Dans ce dernier élément, le caractère ">"est remplacé par l’entité prédéfinie >.
FIGURE 1.9
4.7 - Les sections CDATA et PCDATA
Dans notre exemple, nous avons l’élément resume qui contient une valeur dans laquelle les chevrons "<"et ">" n’ont pas été remplacés par les entités prédéfinies (figure 1.10). Cela est possible avec ce que l’on appelle la section CDATA.
FIGURE 1.10
Une section CDATA est une partie du document XML pouvant contenir toute sorte de chaînes de caractères. Une section CDATA (Character DATA) permet de définir un bloc de caractères ne devant pas être analysés par le processeur XML. Il est ainsi possible de garder dans un bloc de texte un exemple de code à afficher tel quel. Il n’est alors pas nécessaire de recourir à des entités pour afficher les caractères réservés de XML. Le marqueur de début d’un bloc d’une section CDATA doit être <![CDATA[ et le marqueur de fin d’un bloc d’une section CDATA doit être ]]>. Il existe aussi la section PCDATA (Parsed Character DATA) qui, a contrario, contient du texte destiné à être analysé par le processeur XML. Par exemple, une entité qui s’y trouve sera traduite, et tout caractère "<" sera interprété comme indiquant le début d’une balise.
4.8 - L’encodage de documents
On a vu que le prologue d’un fichier XML donne des informations sur l’encodage du document par l’intermédiaire de l’attribut encoding. L’encodage désigne la représentation des caractères sur le disque dur. A un caractère donné est associée une suite de 0 et de 1 en binaire. En raison du grand nombre d’alphabets et de systèmes idéographiques en usage dans le monde, les encodages initialement développés dans les pays occidentaux et fondés sur l’alphabet latin se sont révélés insuffisants. Il a donc fallu développer d’autres encodages donnant accès à des glyphes différents. Comme un fichier enregistré est constitué d’une suite de 0 et de 1 en binaire, il n’est a priori pas possible, sans information supplémentaire, de savoir quelle suite de 0 et de 1 désigne tel ou tel caractère. L’information sur l’encodage donnée dans le prologue du fichier XML indique celui qui a été utilisé lors de l’enregistrement du fichier. Si c’est la seule information disponible pour le traitement du contenu du fichier par le processeur XML, mais qu’elle est incorrecte, alors l’application chargée du traitement devra analyser des données mal formatées. Comme le montre le tableau ci-dessous, certains caractères n’existent pas dans tous les encodages.
Deux cas se présentent alors:
soit le caractère existe dans l’encodage spécifié mais avec un code différent (cas du caractère € dont le code est différent entre l’encodage ISO-8859-1 et l’encodage Windows cp-1252).
soit le caractère n’existe pas dans l’encodage spécifié.
L’affichage, et par conséquent le traitement, est alors différent dans les deux cas. Il est donc préférable, dans tous les cas, d’utiliser systématiquement l’encodage UTF-8 pour réaliser des documents XML.
5 - Règles d’écriture et document bien formé
Il existe un certain nombre de contraintes assez simples mais obligatoires qui s’imposent à la forme d’un document XML.
contrainte n°1: XML est sensible à la casse, ce qui veut dire que XML différencie les majuscules des minuscules. L’élément qualifié par
<titre>
est différent de l’élément qualifié par
<Titre>.
contrainte n°2: un nom d’élément ne peut pas commencer par un chiffre.
contrainte n°3: si le nom d’un élément ne comprend qu’un seul caractère, ce doit être une lettre.
contrainte n°4: si le nom contient au moins deux caractères, le premier caractère peut être un tiret ("-") ou un tiret bas ("_"); le nom peut ensuite être composé de lettres, de chiffres, de tiret ("-"), de tiret bas ("_") ou de deux-points (":").
contrainte n°5: tous les éléments doivent être fermés; les éléments non vides doivent être fermés par une balise fermante, et les éléments vides doivent être fermés par une balise autofermante; les éléments se ferment dans l’ordre inverse de leur ouverture (le dernier élément ouvert est le premier élément à être fermé).
contrainte n°6: les valeurs des attributs doivent être entre guillemets.
contrainte n°7: l’élément racine doit être unique.
Un document XML est dit bien formé (well formed) s’il respecte ces règles d’écriture. D’un point de vue pratique, un éditeur de XML vous assistera dans la composition d’un document XML à l’aide de la coloration syntaxique et de la fonctionnalité de validation. Avec par exemple le logiciel XML Copy Editor, on peut procéder au formatage de l’ensemble du document XML par le menu XML -> Formater la source (ou par la touche F11). On peut savoir aussi si le document XML créé est bien formé en sélectionnant le menu XML -> Vérifier justesse de forme (ou par la touche F2). Dans ce dernier cas, le logiciel affiche un message en bas de la fenêtre pour indiquer si c’est correct ou bien si il y a une erreur (figure 1.11).
FIGURE 1.11
6 - Mise en forme à l’aide de CSS
Un navigateur web est en mesure d’afficher un document XML. Si le document XML affiché n’est pas bien formé, le navigateur web indiquera que des erreurs sont présentes. La figure 1.12 montre notre exemple de document XML visualisé dans Internet Explorer 11 (repère 1) et dans Firefox en version 39 (repère 2). La présentation d’un fichier XML dans un navigateur web permet facilement d’en vérifier le caractère bien formé et l’imbrication des éléments. Cependant, cette mise en forme par défaut n’est pas forcément la plus agréable à l’oeil. Il est alors possible de raffiner quelque peu cette mise en forme par l’emploi du langage CSS (Cascading StyleSheet).
FIGURE 1.12
FIGURE 1.13
Le langage CSS a été développé à l’origine pour mettre en forme des documents HTML et il est surtout connu pour cet usage. Néanmoins, quand un navigateur analyse un document HTML et lui applique une feuille de style CSS, il se contente d’examiner la structure du fichier HTML, d’appliquer aux éléments qui le composent une mise en forme par défaut, puis au besoin de modifier cette mise en forme par défaut en tenant compte de ce qui est spécifié dans la feuille de style CSS. Cette procédure est tout à fait adaptée à l’analyse puis à la mise en forme d’un document XML. Pour appeler une feuille de style CSS dans un document XML, il faut ajouter une instruction de traitement <?xml-stylesheet ?> puis affecter à l’attribut type la valeur text/css (qui indique le type de la feuille de style) et à l’attribut href une valeur qui indique où cette feuille de style est stockée par rapport au document XML. La valeur de l’attribut href peut être une URL si la feuille de style est stockée sur un autre serveur. Quand un fichier XML présentant une telle instruction de traitement est ouvert par un navigateur, si le fichier est bien formé la mise en forme spécifiée par la feuille de style est automatiquement appliquée. La figure 1.13 montre le résultat obtenu avec une mise en forme par une feuille de style mise_en_forme.css.
Notre feuille de style se nomme mise_en_forme.css et elle est stockée au même niveau que le document XML. On ajoute donc l’instruction de traitement <?xml-stylesheet href= "mise_en_forme.css" type= "text/css"?>. Le contenu de cette feuille est le suivant:
/* affichage */
livre {
display: block;
background-color: rgb(253,253,253);
margin-left: 10px;
margin-top: 10px;
margin-right: 10px;
font-family: arial, sans-serif;
}
titre {
display: block;
height: 25px;
background-color: rgb(210,210,210);
font-weight: bold;
color: red;
text-decoration: underline;
}
auteur {
display: block;
height: 25px;
background-color: rgb(220,220,220);
}
nb_tome {
display: block;
height: 25px;
background-color: rgb(230,230,230);
}
stockage {
display: block;
height: 25px;
background-color: rgb(240,240,240);
}
résumé {
display: block;
background-color: rgb(250,250,250);
}
/* contenu additionnel */
nb_tome:before {
content: «nombre de tomes : «;
color: green;
}
stockage:before {
content: «emplacement : «;
color: blue;
}
stockage:after {
color: blue;
}
Ici nous employons des propriétés CSS traditionnelles (vous devez vous référer à la nomenclature de ces propriétés basiques). L’appel aux pseudo-éléments after et before est moins courant, et leur usage est pris en charge par les navigateurs récents. A noter que pour récupérer la valeur d’un attribut d’un élément XML, il faut écrire en CSS la chaîne sous la forme attr(nom_de_attribut).
Le langage d'expression XPath
2
XPath est un langage d’expression qui sert à identifier des groupes de nœuds d’un document XML. Pour pouvoir transformer un document XML, il faut pouvoir extraire des fragments XML (nœuds) d’un document. XPath permet justement de définir ces fragments. Il est à la base de toute transformation de documents XML, réalisée par des feuilles de style XSL (que nous verrons au chapitre suivant). La syntaxe utilisée par XPath est conçue pour être employée dans des valeurs d’attributs XML. Elle est comparable à la syntaxe d’un chemin d’accès qui décrit l’emplacement d’un fichier dans une arborescence de systèmes de fichiers. On pourrait traduire XPath par chemin XML.
Ce chapitre présente une façon pratique de pouvoir évaluer une expression XPath avec un éditeur de XML, présente les expressions nécessaires à l’identification précise des portions d’un document XML, et présente les fonctions XPath 1.0 qui assurent la manipulation des données.
1 - Evaluer une expression XPath avec un éditeur XML
XPath est un langage pour localiser une portion d’un document XML. Sa version 1.0 est devenue une recommandation W3C le 16 novembre 1999. Initialement créé pour fournir une syntaxe et une sémantique aux fonctions communes à XPointer et XSL, XPath a rapidement été adopté par les développeurs comme un langage d’interrogation simple d’emploi.
XPath représente l’organisation d’un document sous la forme d’une arborescence de nœuds. Les principaux nœuds qui peuvent composer une arborescence XPath sont les suivants: nœud racine, nœuds élément, nœuds texte, nœuds attribut, nœuds d’espaces de noms, nœuds d’instruction de traitement et nœuds commentaires. Toutes ces dénominations contribuent à identifier avec précision un nœud donné pour réaliser un fragment XML. L’évaluation d’une expression XPath s’exécute très simplement dans l’éditeur XML Copy Editor. Par exemple on ouvre le document XML intitulé exemple_02_01.xml se trouvant dans le dossier chapitre_02. Il s’agit du document XML que nous avons utilisé au premier chapitre, concernant une bibliothèque de livres, et qui a été complété avec d’autres données. Comme le montre la figure 2.1, pour évaluer une expression XPath, on choisit le menu XML -> Evaluer XPath... (ou bien par la touche F9). Une boite de dialogue s’ouvre (repère 1) dans laquelle on saisit une expression XPath (expression /bibliotheque/livre). En faisant OK, l’éditeur exécute l’évaluation de l’expression XPath en créant un nouveau document (repère 2) contenant les fragments XML trouvés.
FIGURE 2.1
2 - Les chemins de localisation
XPath est un langage en premier lieu qui permet d’extraire des fragments XML dans un document XML par la localisation de nœuds (qu’ils soient des nœuds élément ou qu’ils soient des nœuds attribut). Nous allons nous focaliser ici sur l’écriture d’expressions XPath qui conduisent à la définition de chemins de localisation.
2.1 - Les expressions basiques
Pour localiser un nœud ou un ensemble de nœuds dans un document XML, XPath utilise une notation proche de celle de la désignation d’un fichier dans un système de fichiers. Une recherche d’élément commence toujours à partir d’un point de départ appelé nœud contextuel ou nœud courant. Prenons par exemple le document XML intitulé exemple_02_02.xml qui se trouve dans le dossier chapitre_02. Ce document, qui recense un ensemble de contacts sous forme d’un annuaire, contient les données XML suivantes:
<?xml version="1.0" encoding="UTF-8"?>
<contact>
<personne>
<nom>Pasquier</nom>
<prenom>Laurence</prenom>
<adresse>
<numéro>81</numéro>
<rue>Rue des pyramides</rue>
<ville code="33000">Bordeaux</ville>
</adresse>
</personne>
<personne genre="masculin">
<nom genre="Mr">Baldwin</nom>
<prenom>Jacques</prenom>
<adresse>
<nom>appartement</nom>
<numéro>23</numéro>
<rue>place des lilas</rue>
<ville code="34000">Montpellier</ville>
</adresse>
</personne>
</contact>
Si on exprime l’arborescence du document XML (figure 2.2), le nœud contact est le nœud racine du document. Cette racine possède 2 fils qui sont des nœuds personne. Comme XPath repose sur la nature hiérarchique des documents XML pour référencer les nœuds, la relation entre les nœuds dans ce type de hiérarchie peut être décrite comme une relation familiale. Cela sigifie que les nœuds peuvent être décrits comme des parents, des enfants ou des frères. Le nœud personne est appelé nœud fils du nœud contact et, réciproquement, le nœud contact est un nœud parent des nœuds personne.
FIGURE 2.2
La racine du document s’exprime par le caractère "/" (slash). Une expression XPath qui définit un chemin de localisation est dite expression absolue si son point de départ est la racine du document. Par conséquent, l’évaluation de l’expression XPath constituée par la chaîne "/" retourne un fragment XML qui représente l’ensemble du document XML (prologue compris) car le point de départ (nœud contextuel) est ici la racine. Si l’expression XPath est "/contact", elle retourne l’ensemble du document sans le prologue. L’expression XPath "/contact/personne" retourne tous les nœuds enfants de nom personne du nœud racine, ce qui donne le fragment XML suivant:
<personne>
<nom>Pasquier</nom>
<prenom>Laurence</prenom>
<adresse>
<numéro>81</numéro>
<rue>Rue des pyramides</rue>
<ville code="33000">Bordeaux</ville>
</adresse>
</personne>
<personne genre="masculin">
<nom genre="Mr">Baldwin</nom>
<prenom>Jacques</prenom>
<adresse>
<nom>appartement</nom>
<numéro>23</numéro>
<rue>place des lilas</rue>
<ville code="34000">Montpellier</ville>
</adresse>
</personne>
L’expression XPath "/contact/personne/prenom" retourne tous les nœuds enfants de nom prenom du nœud personne, ce qui donne le fragment XML suivant:
<prenom>Laurence</prenom>
<prenom>Jacques</prenom>
Le caractère "*" offre la possibilité de sélectionner des éléments sans préciser leur parent. L’expression XPath "/contact/personne/*" retourne tous les éléments (nœuds enfants, nœuds petits-fils, etc.) des nœuds personne, ce qui donne le fragment XML suivant:
<nom>Pasquier</nom>
<prenom>Laurence</prenom>
<adresse>
<numéro>81</numéro>
<rue>Rue des pyramides</rue>
<ville code="33000">Bordeaux</ville>
</adresse>
<nom genre="Mr">Baldwin</nom>
<prenom>Jacques</prenom>
<adresse>
<nom>appartement</nom>
<numéro>23</numéro>
<rue>place des lilas</rue>
<ville code="34000">Montpellier</ville>
</adresse>
L’expression XPath "/contact/*/nom" retourne tous les nœuds nom, petits-fils de contact. Pour exécuter cette expression, XPath va commencer par identifier tous les nœuds fils du nœud contextuel (ici la racine), c’est-à-dire tous les nœuds personne et ensuite ne sélectionner que les éléments enfants nom. Ce qui donne le fragment XML suivant:
<nom>Pasquier</nom>
<nom genre="Mr">Baldwin</nom>
Dans ce dernier cas, on voit que le nœud fils nom du nœud adresse du 2ème nœud personne n’est pas sélectionné. Pour cela il faut utiliser la double barre oblique ("//"). Elle sélectionne tous les nœuds enfants (également appelés descendants) du nœud contextuel ainsi que le nœud contextuel lui-même. L’expression XPath "/ contact/personne//nom" retourne à la fois les éléments /contact/personne/nom et les éléments /contact/personne/adresse/nom. Ce qui donne le fragment XML suivant:
<nom>Pasquier</nom>
<nom genre="Mr">Baldwin</nom>
<nom>appartement</nom>
2.2 - Les expressions avancées
Il y a des nœuds qui possèdent des attributs et il est donc parfois nécessaire de sélectionner ces attributs dans un document XML ou bien des éléments satisfaisant à des critères de sélection plus précis. Pour cela il existe des expressions spécifiques à ce type de localisation. Pour sélectionner un attribut, XPath utilise le caractère "@" (arobase). L’expression XPath "/contact/personne/@genre" sélectionne les éléments personne possédant un attribut genre. Ce qui donne le fragment XML suivant:
genre="masculin"
L’expression XPath "/contact/personne/adresse/ville/@code" sélectionne les éléments ville possédant un attribut code. Ce qui donne le fragment XML suivant:
code="33000"
code="34000"
Les sélections d’éléments peuvent se faire de manière encore plus précise. Supposons que nous ne voulions sélectionner que les éléments ville dont l’attribut code soit égal à la valeur 33000. Pour exécuter cela il faut utiliser les caractères "[" et "]" (crochets ouvrant et fermant). L’expression XPath "/contact/personne/adresse/ ville[@code= "33000"]" sélectionne les éléments ville possédant un attribut code égal à la valeur 33000. Ce qui donne le fragment XML suivant:
<ville code="33000">Bordeaux</ville>
A noter qu’une différence majeure est à établir entre les expressions ville/@ code et ville[@code]: l’expression ville/@code sélectionne les attributs code des éléments ville alors que l’expression ville[@code] sélectionne les éléments ville qui possèdent un attribut code.
Les caractères crochets servent aussi à sélectionner des éléments par index suivant leur position dans l’arbre. Pour sélectionner le premier élément personne, fils de contact, on écrira l’expression XPath "/contact/personne[1]". Ce qui donne le fragment XML suivant:
<personne>
<nom>Pasquier</nom>
<prenom>Laurence</prenom>
<adresse>
<numéro>81</numéro>
<rue>Rue des pyramides</rue>
<ville code="33000">Bordeaux</ville>
</adresse>
</personne>
En combinant les syntaxes, on peut arriver à exprimer des expressions de localisation plus subtiles. Par exemple l’expression "/contact/personne[@genre= "masculin"] [1]" commence par rechercher tous les fils personne de contact qui possèdent un attribut genre ayant pour valeur masculin. Et dans cette sélection, il ne retient que le premier (index 1). Ce qui donne le fragment XML suivant:
<personne genre="masculin">
<nom genre="Mr">Baldwin</nom>
<prenom>Jacques</prenom>
<adresse>
<nom>appartement</nom>
<numéro>23</numéro>
<rue>place des lilas</rue>
<ville code="34000">Montpellier</ville>
</adresse>
</personne>
Par contre l’expression "/contact/personne[1] [@genre= "masculin"]" commence par rechercher le premier fils personne de contact, et si ce premier fils possède un attribut genre ayant pour valeur masculin, alors il le sélectionne. Ici notre expression ne retourne rien puisque le premier fils n’a pas d’attribut. Si on écrit l’expression "/contact/personne[2] [@genre= "masculin"]", XPath nous retourne le deuxième fils personne de contact. Ce qui donne le fragment XML suivant:
<personne genre="masculin">
<nom genre="Mr">Baldwin</nom>
<prenom>Jacques</prenom>
<adresse>
<nom>appartement</nom>
<numéro>23</numéro>
<rue>place des lilas</rue>
<ville code="34000">Montpellier</ville>
</adresse>
</personne>
2.3 - Les noms d’axe
Nous venons de voir que nous sommes capables de localiser des nœuds éléments et des nœuds attributs. Or il est possible de se déplacer autrement dans une arborescence XPath grâce à des chemins qui s’appellent nom d’axe. Il existe 13 axes définis dans XPath et ils peuvent être utilisés dans des expressions.
Le premier des axes, qui est le plus simple, est l’axe self. Il ne contient que le nœud contextuel. Si on écrit l’expression "/self::node()", cela nous retourne le document XML entier (prologue compris). L’axe le plus souvent utilisé est l’axe child qui contient les enfants du nœud contextuel.
Pour sélectionner les enfants, les petits-enfants, etc. du nœud contextuel, ce que nous appelons la descendance, nous utiliserons l’axe descendant. L’axe descendant-or-self contient le nœud contextuel et tous ses descendants (il est égal au caractère "//" c'est-à-dire la double barre oblique). Pour remonter dans l’arbre, il existe l’axe parent qui contient le nœud parent du nœud contextuel (s’il existe) et l’axe ancestor qui contient le nœud parent, le grand-parent, etc. Symétriquement à l’axe descendant-or-self, il existe l’axe ancestor-or-self qui contient le nœud contextuel et tous ses ancêtres.
On peut accéder à la localisation des nœuds frères en utilisant l’un des quatre axes following-sibling, preceding-sibling, following et preceding. La direction followingou preceding fait référence à l’ordre dans lequel les éléments sont écrits dans le document XML parcouru. L’axe following-sibling identifie les nœuds frères qui suivent le nœud contextuel, et l’axe preceding-sibling identifie les nœuds frères qui précèdent le nœud contextuel. L’axe following identifie tous les nœuds frères suivants ainsi que leurs descendants éventuels. L’axe preceding identifie tous les nœuds frères précédant le nœud contextuel ainsi que leurs descendants éventuels. La localisation des attributs du nœud contextuel se fait par l’axe attribute (équivalent à l’arobase). Le dernier axe namespace sélectionne les nœuds d’espace de noms du nœud contextuel, s’ils existent.
3 - Les opérateurs XPath
XPath permet d’effectuer des calculs et des opérations simples entre les nœuds par l’intermédiaire d’opérateurs. Avec ces opérateurs, il est possible de comparer des expressions, voire de réaliser des opérations élémentaires sur des nœuds. Les opérateurs de comparaison sont:
opérateur "=" représente le test d’égalité:
elem= "mot"
renvoie
true
si le contenu du nœud
elem
vaut
"mot", false
dans le cas contraire.
opérateur "!=" représente le test de différence:
elem != "mot"
renvoie
true
si le contenu du nœud
elem
ne vaut pas
"mot", false
dans le cas contraire.
opérateur "<" représente le strictement inférieur:
nn<10.25
renvoie
true
si
nn
est strictement inférieur à
10.25, false
dans le cas contraire.
opérateur "<=" représente l’inférieur ou égal:
nn<=10.25
renvoie
true
si
nn
est inférieur ou égal à
10.25, false
dans le cas contraire.
opérateur ">" représente le strictement supérieur:
nn>10.25
renvoie
true
si
nn
est strictement supérieur à
10.25, false
dans le cas contraire.
opérateur ">=" représente le supérieur ou égal:
nn>=10.25
renvoie
true
si
nn
est supérieur ou égal à
10.25, false
dans le cas contraire.
Les opérateurs élémentaires sont:
opérateur "+" représente l’addition:
nn1 + nn2
renvoie le résultat de la somme de ces deux nombres.
opérateur "-" représente la soustraction:
nn1 - nn2
renvoie le résultat de la différence de ces deux nombres.
opérateur "*" représente la multiplication:
nn1 * nn2
renvoie le résultat du produit de ces deux nombres.
opérateur "div" représente la division:
nn1 div nn2
renvoie le quotient de la division euclidienne de
nn1
par
nn2.
opérateur
"mod"
représente le reste de la division euclidienne:
nn1 mod nn2
renvoie le reste de la division euclidienne de
nn1
par
nn2.
4 - Les fonctions XPath
Les expressions XPath ne se limitent pas à la sélection d’un ou plusieurs nœuds. Il est possible de calculer le nombre de nœuds dans un document XML, de sommer les valeurs numériques de certains attributs ou bien encore d’extraire des sous-chaînes du contenu d’un élément ou d’un attribut. Toutes ces manipulations et ces calculs se font par l’intermédiaire de fonctions XPath réparties en quatre catégories: les fonctions de nœuds, les fonctions booléennes, les fonctions sur les chaînes de caractères et les fonctions numériques.
4.1 - Les fonctions de nœuds
Les fonctions de nœuds servent à déterminer le nombre de nœuds dans un ensemble ainsi que la position du nœud. Ces fonction de nœuds sont:
count(ensemble_de_ nœuds)
qui détermine le nombre de nœuds d’un ensemble nœuds.
position()
qui retourne la position numérique d’un nœud.
last()
qui retourne la valeur du dernier nœud d’un ensemble de nœuds.
name()
qui retourne le nom de l’élément sélectionné.
Si on applique la fonction count() sur le document XML ci-dessous pour comptabiliser des nœuds, l’expression count(/ROOT/AA) retournera la valeur 3, l’expression count(/ROOT/BB) retournera la valeur 2, l’expression count(/ROOT/ CC) retournera la valeur 2, l’expression count(/ROOT/DD) retournera la valeur 1 et l’expression count(/ROOT/*) retournera la valeur 9.
<?xml version="1.0" encoding="UTF-8"?>
<ROOT>
<AA/>
<BB/>
<CC/>
<AA/>
<AA/>
<BB/>
<CC/>
<DD/>
<EE/>
</ROOT>
La fonction position() permet de sélectionner un nœud particulier dans l’éventualité où il en existe plusieurs. La numérotation des positions commence à 1. Dans l’exemple ci-dessous, l’expression /ROOT/AA[position()=2] retourne le 2ème fils de ROOT. L’écriture raccourcie est comme on l’a déjà vu précédemment /ROOT/AA[2].
La fonction last() sélectionne le dernier élément contenu dans l’élément correspondant au nœud contextuel. L’expression /ROOT/AA/BB[position()=last()] permet de récupérer le dernier fils d’un nœud.
L’expression /ROOT/AA[BB[last()<2]] permet de récupérer les nœuds qui ont moins de N fils.
La fonction name()
