XML FR
XML FR
XML FR
Présentation de XML
Contrairement à HTML, qui est à considérer comme un langage défini et figé (avec un
nombre de balises limité), XML peut être considéré comme un métalangage permettant de
définir d'autres langages, c'est-à-dire définir de nouvelles balises permettant de décrire la
présentation d'un texte (Qui n'a jamais désiré une balise qui n'existait pas ?).
La force de XML réside dans sa capacité à pouvoir décrire n'importe quel domaine de
données grâce à son extensibilité. Il va permettre de structurer, poser le vocabulaire et la
syntaxe des données qu'il va contenir.
En réalité les balises XML décrivent le contenu plutôt que la présentation (contrairement À
HTML). Ainsi, XML permet de séparer le contenu de la présentation .. ce qui permet par
exemple d'afficher un même document sur des applications ou des périphériques différents
sans pour autant nécessiter de créer autant de versions du document que l'on nécessite de
représentations !
XML a été mis au point par le XML Working Group sous l'égide du World Wide Web
Consortium (W3C) dès 1996. Depuis le 10 février 1998, les spécifications XML 1.0 ont été
reconnues comme recommandations par le W3C, ce qui en fait un langage reconnu. (Tous les
documents liés à la norme XML sont consultables et téléchargeables sur le site web du W3C,
http://www.w3.org/XML/)
XML est un sous ensemble de SGML (Standard Generalized Markup Language), défini par
le standard ISO8879 en 1986, utilisé dans le milieu de la Gestion Electronique Documentaire
(GED). XML reprend la majeure partie des fonctionnalités de SGML, il s'agit donc d'une
simplification de SGML afin de le rendre utilisable sur le web !
XML est un format de description des données et non de leur représentation, comme c'est le
cas avec HTML. La mise en page des données est assurée par un langage de mise en page
tiers. A l'heure actuelle (fin de l'année 2000) il existe trois solutions pour mettre en forme un
document XML :
CSS (Cascading StyleSheet), la solution la plus utilisée actuellement, étant donné qu'il
s'agit d'un standard qui a déjà fait ses preuves avec HTML
XSL (eXtensible StyleSheet Language), un langage de feuilles de style extensible
développé spécialement pour XML. Toutefois, ce nouveau langage n'est pas reconnu
pour l'instant comme un standard officiel
XSLT (eXtensible StyleSheet Language Transformation). Il s'agit d'une
recommandation W3C du 16 novembre 1999, permettant de transformer un document
XML en document HTML accompagné de feuilles de style
Structure des documents XML
XML fournit un moyen de vérifier la syntaxe d'un document grâce aux DTD (Document Type
Definition). Il s'agit d'un fichier décrivant la structure des documents y faisant référence grâce
à un langage adapté. Ainsi un document XML doit suivre scrupuleusement les conventions de
notation XML et peut éventuellement faire référence à une DTD décrivant l'imbrication des
éléments possibles. Un document suivant les règles de XML est appelé document bien formé.
Un document XML possédant une DTD et étant conforme à celle-ci est appelé document
valide.
XML permet donc de définir un format d'échange selon les besoins de l'utilisateur et offre des
mécanismes pour vérifier la validité du document produit. Il est donc essentiel pour le
receveur d'un document XML de pouvoir extraire les données du document. Cette opération
est possible à l'aide d'un outil appelé analyseur (en anglais parser, parfois francisé en
parseur).
Le parseur permet d'une part d'extraire les données d'un document XML (on parle d'analyse
du document ou de parsing) ainsi que de vérifier éventuellement la validité du document.
OFX : Open Financial eXchange pour les échanges d'informations dans le monde
financier
MathML : Mathematical Markup Language permet de représenter des formules
mathématique
CML : Chemical Markup Language permet de décrire des composés chimiques
SMIL : Synchronized Multimedia Integration Language permet de créer des
présentations multimédia en synchronisant diverses sources : audio, vidéo, texte,...
La norme XML en tant que telle doit être vue comme un outil permettant de définir un
langage (on dit alors qu'il s'agit d'un métalangage), permettant de créer des documents
structurés à l'aide de balises.
<balise>
Ainsi, un document XML, c'est-à-dire le fichier créé en suivant les spécifications de la norme
XML pourra par exemple ressembler à ceci :
<annuaire>
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<telephone>555-123456</telephone>
<email>[email protected]</email>
</personne>
<personne>
...
</personne>
</annuaire>
Enfin il est possible d'ajouter des commentaires dans le document XML de la manière
suivante :
La première partie, appelée prologue permet d'indiquer la version de la norme XML utilisée
pour créer le document (cette indication est obligatoire) ainsi que le jeu de caractères (en
anglais encoding) utilisé dans le document (attribut facultatif, ici on spécifie qu'il s'agit du jeu
ISO-8859-1, jeu LATIN, pour permettre de prendre en compte les accents français). Ainsi le
prologue est une ligne du type
Le prologue se poursuit avec des informations facultatives sur des instructions de traitement à
destination d'applications particulières. Leur syntaxe est la suivante :
<?instruction de traitement?>
Le second élément est une déclaration de type de document (à l'aide d'un fichier annexe
appelé DTD - Document Type Definition)
Et enfin la dernière composante d'un fichier XML est l'arbre des éléments (comme celui ci-
dessus).
L'arbre des éléments, c'est-à-dire le véritable contenu du document XML, est constitué d'une
hiérarchie de balises comportant éventuellement des attributs.
Un attribut est une paire clé valeur écrit sous la forme Cle="Valeur", ainsi une balise affectée
d'un attribut aura la syntaxe suivante :
<balise cle="valeur">
Toute donnée est ainsi encapsulée entre une balise ouvrante <balise> et une balise fermante
</balise> (Sachant qu'une donnée peut éventuellement être un ensemble d'éléments XML).
Ainsi un élément vide est uniquement constitué d'une balise spécifique dont la syntaxe est la
suivante : <balise/>.
D'autre part, il est interdit en XML de faire chevaucher des balises, c'est-à-dire d'avoir une
succession de balises du type :
<balise1>
<balise2>
</balise1>
</balise2>
D'autre part, il est possible entre les balises (donc pas à l'intérieur d'une balise) d'ajouter :
des espaces
des tabulations
des retours chariots
Cela est très utile pour définir une indentation des balises (ce qui est possible puisqu'elles ne
se chevauchent pas).
<annuaire>
<personne class = "etudiant">
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<telephone>555-123456</telephone>
<email>[email protected]</email>
</personne>
</annuaire>
Le rôle de la DTD
XML permet d'utiliser un fichier afin de vérifier qu'un document XML est conforme à une
syntaxe donnée. La norme XML définit ainsi une définition de document type appelée DTD
(Document Type Definition), c'est-à-dire une grammaire permettant de vérifier la conformité
du document XML. La norme XML n'impose pas l'utilisation d'une DTD pour un document
XML, mais elle impose par contre le respect exact des règles de base de la norme XML.
Déclarer un élément
Pour pouvoir créer un document XML il est utile dans un premier temps de définir les
éléments pouvant être utilisés, ou plus exactement les informations que l'on désire utiliser.
Le paramètre modèle représente soit un type de donnée prédéfini, soit une règle d'utilisation
de l'élément.
Ainsi un élément nommé Nom contenant un type #PCDATA sera déclaré de la façon suivante
dans la DTD :
Cet élément pourra être écrit de la façon suivante dans le document XML :
<Nom>Pillou</Nom>
D'autre part il est possible de définir des règles d'utilisation, c'est-à-dire les éléments XML
qu'un élément peut ou doit contenir. Cette syntaxe se fait à l'aide de notations spécifiques dont
voici un récapitulatif :
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<telephone>555-123456</telephone>
<email>[email protected]</email>
</personne>
ou bien
<personne>
<nom>Pillou</nom>
<prenom>Jeff</prenom>
<telephone>555-542136</telephone>
</personne>
Il est possible d'ajouter des propriétés à un élément particulier en lui affectant un attribut,
c'est-à-dire une paire clé/valeur. Ainsi avec XML la syntaxe pour définir un attribut est la
suivante :
Pour définir une valeur par défaut il suffit de faire suivre l'énumération par la valeur
désirée entre guillemets :
Enfin chacun de ces types d'attributs peut être suivi d'un mot clé particulier permettant de
spécifier le niveau de nécessité de l'attribut :
#IMPLIED signifie que l'attribut est optionnel, c'est-à-dire non obligatoire
#REQUIRED signifie que l'attribut est obligatoire
#FIXED signifie que l'attribut sera affecté d'une valeur par défaut s'il n'est pas défini.
Il doit être immédiatement suivi de la valeur entre guillemets
Ce qui signifie que l'on affecte à l'élément disque deux attributs IDdisk et type. Le premier
attribut est de type atomique, il s'agit d'un identifiant unique obligatoire. L'élément type peut
être soit K7, MiniDisc, Vinyl ou CD, sachant que ce dernier sera affecté par défaut...
Déclarer des notations
XML permet de définir une application par défaut à lancer pour ouvrir des documents non
XML encapsulés dans le code XML.
Il est ainsi possible d'associer les images JPG au programme Paint Shop Pro (psp.exe) grâce à
la syntaxe suivante :
XML permet de créer des entités, c'est-à-dire de déclarer un groupe d'éléments sous un nom
afin de ne pas avoir à réécrire ces derniers plusieurs fois dans la DTD s'ils se répètent, dans le
même esprit que les macros dans les éditeurs de texte. D'autre part, l'utilisation d'entités dans
un document XML permet :
Entités générales
Les entités générales permettent de définir des éléments pouvant être substitués dans le corps
du document XML (bien qu'ils soient définis au sein de la DTD et non du document XML lui-
même). La syntaxe d'une entité générale est la suivante :
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<site>&site;</site>
<email>webmaster@&site;</email>
</personne>
Le parseur transformera automatiquement chacune des entités contenues dans le code XML,
en chaînes de caractères :
<personne>
<nom>Pillou</nom>
<prenom>Jean-Francois</prenom>
<site>commentcamarche.net</site>
<email>[email protected]</email>
</personne>
Les entités générales peuvent aussi être contenues dans un fichier extérieur (afin d'être utilisé
par plusieurs DTD par exemple), on parle alors d'entité externe. La syntaxe d'une entité
externe est la suivante :
<!ENTITY nom_de_l_entite SYSTEM "nom_du_fichier">
Dans l'exemple suivant, le contenu du fichier ccm.txt (situé dans le même répertoire que la
DTD) sera inséré dans le fichier XML à chaque fois que l'entité &ccm; sera rencontrée :
<!ENTITY ccm SYSTEM "ccm.txt">
Entités paramètres
Les entités paramètres permettent d'utiliser des entités dans les DTD elles-même. La syntaxe
de la déclaration d'une entité paramètre est la suivante :
Entités caractères
Les entités caractères sont des caractères réservés du XML représentés sous forme d'entités
générales afin de pouvoir insérer ces caractères réservés dans le document XML.
Il est également possible de définir des entités caractères pour n'importe quel caractère en
utilisant le code hexadécimal du caractère :
XML définit un système permettant de créer des balises modulaires, c'est-à-dire pouvoir
donner la possibilité d'utiliser des balises provenant de différents langages à balise au sein
d'un même document grâce à la notion d'espace de noms.
La définition d'un espace de nom permet d'associer toutes les balises d'un langage à un groupe
afin d'être capable de mêler différents langages à balise dans un même document XML (être
capable de dissocier les éléments de HTML contenus dans le document des balises XML, ou
mieux : pouvoir mettre du HTML, MathML, et CML dans un même document).
Fondamentalement il n'y a pas de risques que des balises XML interfèrent avec des balises
HTML car ces deux langages ont été mis au point par le même organisme (W3C). Par contre,
étant donné que XML est un méta-langage, il permet par définition de définir de nouvelles
balises. Ainsi, il se peut que deux organismes mettent au point des langages dont certaines
balises portent le même nom, ce qui pose un problème si on désire utiliser des éléments des
deux langages au sein d'un même document.
Introduction à XSL
XML est un langage de structuration des données, et non de représentation des données. Ainsi
XSL (eXtensible StyleSheet Language) est un langage recommandé par le W3C pour effectuer
la représentation des données de documents XML. XSL est lui-même défini avec le
formalisme XML, cela signifie qu'une feuille de style XSL est un document XML bien formé.
XSL est un langage permettant de définir des feuilles de style pour les documents XML au
même titre que les CSS (Cascading StyleSheets) pour le langage HTML ou bien DSSSL
(Document Style Semantics and Specification Language) pour le SGML. XSL est d'ailleurs
inspiré de DSSSL dont il reprend beaucoup de fonctionnalités et est compatible avec les CSS
(il s'agit d'un sur-ensemble des CSS).
Toutefois, contrairement aux CSS, XSL permet aussi de retraiter un document XML afin d'en
modifier totalement sa structure, ce qui permet à partir d'un document XML d'être capable de
générer d'autres types de documents (PostScript, HTML, Tex, RTF, ...) ou bien un fichier
XML de structure différente.
Ainsi la structuration des données (définie par XML) et leur représentation (définie par un
langage tel que XSL) sont séparées. Cela signifie qu'il est possible à partir d'un document
XML de créer des documents utilisant différentes représentations (HTML pour créer des
pages web, WML pour les mobiles WAP, ...).
XSLT et XSL/FO
Un document XML peut être représenté comme une structure arborescente. Ainsi
XSLT permet de transformer les documents XML à l'aide de feuilles de style
contenant des règles appelées template rules (ou règles de gabarit en français).
Chaque template rule définit des traitements à effectuer sur un élément (noeud ou
feuille) de l'arbre source. On appelle "patterns" (en français motifs, parfois "éléments
cibles") les éléments de l'arbre source.
L'arbre source peut être entièrement remodelé et filtré ainsi qu'ajouter du contenu à
l'arbre résultat, si bien que l'arbre résultat peut être radicalement différent de l'arbre
source.
le langage de formattage des données (XSL/FO), c'est-à-dire un langage permettant
de définir la mise en page (affichage de texte ou de graphiques) de ce qui a été créé
par XSLT.
Une fois l'arbre source créé, XSL/FO permet de formatter le résultat, c'est-à-dire
d'interpréter l'arbre résultat, ou plus exactement les objets de flux le composant en leur
appliquant des objets de mise en forme afin d'en faire une représentation visuelle
(papier, écran, ...)
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
</xsl:template >
</xsl:stylesheet>
Une feuille de style XSL (enregistré dans un fichier dont l'extension est .xsl) peut être liée à
un document XML (de telle manière à ce que le document XML utilise la feuille XSL) en
insérant la balise suivante au début du document XML :
<personne>
<nom>Pillou</nom>
<prenom>Jean-François</prenom>
</personne>
<personne>
<nom>VanHaute</nom>
<prenom>Nico</prenom>
</personne>
<personne>
<nom>Andrieu</nom>
<prenom>Seb</prenom>
</personne>
pourra être transformé en les tags HTML suivants :
<ul>
<li>Pillou - Jean-François</li>
<li>VanHaute - Nico</li>
<li>Andrieu - Seb</li>
</ul>
La notation Xpath permet de définir des patterns, c'est-à-dire des chaînes de caractères
permettant de repérer un noeud dans le document XML. Les principaux patterns sont :
Voici un exemple de feuille XSL permettant d'effectuer la transformation XML vers HTML
décrite ci-dessus :
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
<xsl:template match="/">
<HTML>
<HEAD>
<TITLE>Titre de la page</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<xsl:apply-templates/>
</BODY>
</HTML>
</xsl:template >
<ul>
<li>
<xsl:value-of select="nom"/>
-
<xsl:value-of select="prenom"/>
</li>
</ul>
</xsl:template >
</xsl:stylesheet>
Voici la signification de cette feuille XSL
Le premier tag <xsl:template> permet d'appliquer une transformation à l'ensemble du
document (la valeur "/" de l'attribut match indique l'élément racine du document
XML). Ce tag contient des balises HTML qui seront transmises dans l'arbre résultat
L'élément <xsl:apply-templates/> indique le traitement de tous les enfants directs de
la racine.
La balise <xsl:template match="personne" > permet d'aller traiter les éléments de
type personne
Enfin les deux éléments <xsl:value-of select="nom"/> et <xsl:value-of
select="prenom"/> permettent de recuperer les valeurs des balises nom et prenom
Auteur: sebsauvage
[XSL-FO] Comment lire
Mise à jour: mercredi 13 décembre 2006 à 17:17:24
un fichier .FO/.FOB ?
Par: sebsauvage
Le format XSL-FO est un format de description de page comme PDF ou DVI.
Ces fichiers ont généralement l'extension .fo ou .fob, et parfois .xml
(On peut les repérer facilement en les ouvrant avec le Bloc-Note: On trouve <fo:root dans les
premières lignes).
Solution 1
Solution 2
XSLT et XSL/FO
Un document XML peut être représenté comme une structure arborescente. Ainsi
XSLT permet de transformer les documents XML à l'aide de feuilles de style
contenant des règles appelées template rules (ou règles de gabarit en français).
Chaque template rule définit des traitements à effectuer sur un élément (noeud ou
feuille) de l'arbre source. On appelle "patterns" (en français motifs, parfois "éléments
cibles") les éléments de l'arbre source.
L'arbre source peut être entièrement remodelé et filtré ainsi qu'ajouter du contenu à
l'arbre résultat, si bien que l'arbre résultat peut être radicalement différent de l'arbre
source.
Une fois l'arbre source créé, XSL/FO permet de formater le résultat, c'est-à-dire
d'interpréter l'arbre résultat, ou plus exactement les objets de flux le composant en leur
appliquant des objets de mise en forme afin d'en faire une représentation visuelle
(papier, écran, ...)
Les template rules sont des balises XSL permettant de définir des opérations à réaliser sur
certains éléments du document XML utilisant la page XSL, c'est-à-dire généralement de
transformer un tag XML et au moins un tag HTML (généralement plusieurs).
<personne>
<nom>Pillou</nom>
<prenom>Jean-François</prenom>
</personne>
<personne>
<nom>VanHaute</nom>
<prenom>Nico</prenom>
</personne>
<personne>
<nom>Andrieu</nom>
<prenom>Seb</prenom>
</personne>
pourra être transformé en les tags HTML suivants :
<ul>
<li>Pillou - Jean-François</li>
<li>VanHaute - Nico</li>
<li>Andrieu - Seb</li>
</ul>
<xsl:template match="conditions"/>
La notation Xpath permet de définir des patterns, c'est-à-dire des chaînes de caractères
permettant de repérer un noeud dans le document XML. Les principaux patterns sont :
Voici un exemple de feuille XSL permettant d'effectuer la transformation XML vers HTML
décrite ci-dessus :
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
<xsl:template match="/">
<HTML>
<HEAD>
<TITLE>Titre de la page</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<xsl:apply-templates/>
</BODY>
</HTML>
</xsl:template >
<ul>
<li>
<xsl:value-of select="nom"/>
-
<xsl:value-of select="prenom"/>
</li>
</ul>
</xsl:template >
</xsl:stylesheet>
Voici la signification de cette feuille XSL
Le premier tag <xsl:template> permet d'appliquer une transformation à l'ensemble du
document (la valeur "/" de l'attribut match indique l'élément racine du document
XML). Ce tag contient des balises HTML qui seront transmises dans l'arbre résultat
L'élément <xsl:apply-templates/> indique le traitement de tous les enfants directs de
la racine.
La balise <xsl:template match="personne" > permet d'aller traiter les éléments de
type personne
Enfin les deux éléments <xsl:value-of select="nom"/> et <xsl:value-of
select="prenom"/> permettent de recuperer les valeurs des balises nom et prenom
Les éléments de transformations permettent de sélectionner et effectuer des opérations sur les
éléments du document XML. Leur syntaxe est la suivante :
<xsl:nom [attributs]/>
Remarquez la présence du / indiquant que la balise ne possède pas de balise fermante.
Elément Utilité
xsl:apply-
Importe une feuille de style importée
imports
xsl:apply- Indique au processeur XSL de traiter les éléments enfants directs en leur
templates appliquant les template rules définies dans la feuille XSL. L'attribut select
permet de spécifier certains éléments enfants auxquels la transformation doit
être appliquée
xsl:attribute-
Permet de créer un attribut à associer à un élément
set
xsl:attribute- Permet de nommer une liste d'attributs, pouvant être appliqués à un élément
set particulier
xsl:template Permet de charger un canevas (template) grâce à son nom.
Structure conditionnelle de type "case" (utilisé en combinaison avec xsl:when
xsl:choose
et/ou xsl:otherwise)
xsl:comment Crée un commentaire dans l'arbre résultat
xsl:copy Copie le noeud courant dans l'arbre résultat
xsl:copy-of Copie le noeud sélectionné par le modèle dans l'arbre résultat
xsl:decimal-
Déclare un format de nombre décimal
format
xsl:element Permet de créer un élément avec le nom spécifié
xsl:for-each Permet d'appliquer un canevas à chaque neoud correspondant au modèle
xsl:if Permet d'effectuer un test conditionnel sur le modèle indiqué
xsl:apply-templates
<voiture>
<marque>Volkswagen</marque>
<immatriculation>9999 ZZ 99</immatriculation>
<modele>Golf Match</modele>
<couleur>Bleu clair</couleur>
</voiture>
et la feuille XSL associée :
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
<xsl:template match="voiture">
<Auto>
<xsl:apply-templates/>
</Auto>
</xsl:template >
</xsl:stylesheet>
Cette feuille de style donnera le résultat suivant :
<Auto></Auto>
L'élément apply-templates permet donc uniquement d'appliquer les modifications l'entourant,
sans insérer de contenu supplémentaire.
xsl:value-of
Pour insérer le contenu des éléments sélectionnés par la règle de gabarit (template rule), il
suffit d'utiliser l'élément value-of, qui permet d'insérer le contenu de la balise sélectionnée.
En reprenant le même document XML que celui présent ci-dessus, il est possible de définir la
feuille de style XSL suivante :
<xsl:template match="voiture">
<table border="1">
<tr><th>Voiture</th></tr>
<tr><xsl:apply-templates/></tr>
</table>
</xsl:template >
<xsl:template match="marque">
<td><xsl:value-of/></td>
</xsl:template >
<xsl:template match="immatriculation">
<td><xsl:value-of/></td>
</xsl:template >
Cette feuille de style donnera le résultat suivant :
<table border="1">
<tr><th>Voiture</th></tr>
<td>Volkswagen</td>
<td>9999 ZZ 99</td>
</table>
xsl:apply-imports
Par exemple, dans la feuille XSL suivante, la feuille import.xsl est importée grâce à l'élément
<?xsl:import?>,
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
<xsl:import href="import.xsl"/>
<xsl:template match="voiture">
<Effet>
<xsl:apply-imports/>
</Effet>
</xsl:template >
</xsl:stylesheet>
Voici la feuille de style importée :
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40"
result-ns="">
<xsl:template match="voiture">
<EffetImporte>
<xsl:apply-imports/>
</EffetImporte>
</xsl:template >
</xsl:stylesheet>
xsl:for-each
Les régles de gabarit permettent grâce à l'élément <xsl:template> de sélectionner les éléments
sur lesquels on désire effectuer une transformation. Grâce à l'élément <xsl:for-each>, il est
possible de sélectionner des éléments enfants et de leur appliquer une règle de transformation.
La sélection des éléments enfant se fait à l'aide de l'attribut select de la balise <xsl:for-each>,
utilisant les patterns XSL au même titre que l'élément <xsl:template>.
<xsl:template match="">
<EffetImporte>
<xsl:apply-imports/>
</EffetImporte>
</xsl:template >
</xsl:stylesheet>
Introduction à XLL
XLL est un langage de description des liens hypertextes pour XML. XLL est aussi connu sous
le nom de XML:Part2, il s'agit donc de la seconde partie de la norme XML (encore au stade
de document de travail du W3C, contrairement à XML (Part1) qui est désormais une
recommandation du W3C).
HyTime
TEI
Liens sponsorisés
XML permet de définir la structure du document uniquement, ce qui permet d'une part de
pouvoir définir séparément la présentation de ce document, d'autre part d'être capable de
récupérer les données présentes dans le document pour les utiliser.
Toutefois la récupération des données encapsulées dans le document nécessite un outil appelé
analyseur syntaxique (en anglais parser), permettant de parcourir le document et d'en extraire
les informations qu'il contient.
Qu'appelle-t-on un analyseur ?
les parseurs validants (validating) permettant de vérifier qu'un document XML est
conforme à sa DTD
les parseurs non validants (non-validating) se contentant de vérifier que le document
XML est bien formé (c'est-à-dire respectant la syntaxe XML de base)
Les analyseurs XML sont également divisés selon l'approche qu'ils utilisent pour traiter le
document. On distingue actuellement deux types d'approches :
Les API utilisant une approche hiérarchique : les analyseurs utilisant cette technique
construisent une structure hiérarchique contenant des objets représentant les éléments
du document, et dont les méthodes permettent d'accèder aux propriétés. La principale
API utilisant cette approche est DOM (Document Object Model)
Les API basés sur un mode événementiel permettent de réagir à des événements
(comme le début d'un élément, la fin d'un élément) et de renvoyer le résultat à
l'application utilisant cette API. SAX (Simple API for XML est la principale interface
utilisant l'aspect événementiel
Introduction à DOM
DOM (Document Object Model, traduisez modèle objet de document) est une spécification du
W3C (World Wide Web Consortium) définissant la structure d'un document sous forme d'une
hiérarchie d'objets, afin de simplifier l'accès aux éléments constitutifs du document.
Plus exactement DOM est un langage normalisé d'interface (API, Application Programming
Interface), indépendant de toute plateforme et de tout langage, permettant à une application de
parcourir la structure du document et d'agir dynamiquement sur celui-ci. Ainsi Javascript et
ECMAScript utilisent DOM pour naviguer au sein du document HTML, ce qui leur permet
par exemple de pouvoir récupérer le contenu d'un formulaire, le modifier, ...
Introduction à SAX
SAX est une API basée sur un modèle événementiel, cela signifie que SAX permet de
déclencher des événements au cours de l'analyse du document XML.
Une application utilisant SAX implémente généralement des gestionnaires d'événements, lui
permettant d'effectuer des opérations selon le type d'élément rencontré.
<personne>
<nom>Pillou</nom>
<prenom>Jean-François</prenom>
</personne>
Une interface événementielle telle que l'API SAX permet de créer des événements à partir de
la lecture du document ci-dessus. Les événements générés seront :
start document
start element: personne
start element: nom
characters: Pillou
end element: nom
start element: prenom
characters: Jean-François
end element: prenom
end element: personne
end document
Ainsi, une application basée sur SAX peut gérer uniquement les éléments dont elle a besoin
sans avoir à construire en mémoire une structure contenant l'intégralité du document.
Les analyseurs utilisant l'interface DOM souffrent du fait que cette API impose de construire
un arbre en mémoire contenant l'intégralité des éléments du document en mémoire quelle que
soit l'application. Ainsi pour de gros documents (dont la taille est proche de la quantité de
mémoire présente sur la machine) DOM devient insuffisant. De plus, cela rend l'utilisation de
DOM lente, c'est la raison pour laquelle la norme DOM est généralement peu respectée car
chaque éditeur l'implémente selon ses besoins, ce qui provoque l'apparition de nombreux
parseurs utilisant des interfaces propriétaires...
Ainsi de plus en plus d'applications se tournent vers des API événementielles telles que SAX,
permettant de traiter uniquement ce qui est nécessaire.
Le standard RSS
Un flux RSS est un simple fichier texte contenant des informations structurées au format
XML, permettant de décrire de façon fine le contenu du canal et de chacun des items qui le
constituent. Il existe plusieurs versions du standard RSS :
RSS 0.91 (Rich Site Summary) représente une évolution mineure des spécifications de
format RSS originel mis au point par la société Netscape ;
RSS 1.0 (RDF Site Summary) est une spécification alternative, issue du standard
RDF ;
RSS 2.0 (Really Simple Syndication) est une amélioration du standard RSS 0.91, mise
au point par Dave Winer.
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns="http://purl.org/rss/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
>
<channel rdf:about="http://url">
<title>Titre du canal RSS</title>
<link>URL d'une page décrivant le canal RSS</link>
<description>Description globale du fil
RSS</description>
<image rdf:resource="http://url_de_l_image" />
<items>
<rdf:Seq>
<rdf:li rdf:resource="http://url_item1" />
<rdf:li rdf:resource="http://url_item2" />
<rdf:li rdf:resource="http://url_item3" />
<rdf:li rdf:resource="http://url_item4" />
</rdf:Seq>
</items>
<dc:publisher>Adresse électronique de
l'éditeur</dc:publisher>
<dc:rights>Nom de l'éditeur</dc:rights>
</channel>
<image rdf:about="http://imge">
<title>Titre de l'image du canal RSS </title>
<link>http://lien_associé_à_l_image</link>
<url>http://url_de_l_image</url>
</image>
<item rdf:about="http://url_item1">
<title>Titre de l'item n°1</title>
<link>http://url_item1</link>
<description>Description de l'item n°1</description>
</item>
<item rdf:about="http://url_item2">
<title>Titre de l'item n°2</title>
<link>http://url_item2</link>
<description>Description de l'item n°2</description>
</item>
<item rdf:about="http://url_item2">
...
</item>
</rdf:RDF>
<copyright>Nom de l'éditeur</copyright>
<webMaster>Adresse électronique de l'éditeur</webMaster>
<image>
<title>Titre de l'image</title>
<url>http://lien_associé_à_l_image</url>
<link>Lien associé à l'image/</link>
<width>largeur en pixels</width>
<height>Hauteur en pixels</height>
</image>
<item>
<title>Titre de l'item n°1</title>
<description>Description de l'item n°1</description>
<link>http://url_item1</link>
</item>
<item>
<title>Titre de l'item n°2</title>
<description>Description de l'item n°2</description>
<link>http://url_item2</link>
</item>
</channel>
</rss>
Plus d'information