Avant-propos

La première version de ce document a été écrite en 2001. A cette époque, seul IE implémentait partiellement le support du XML et encore, comme la norme n'était pas encore fixée, de nombreuses manipulations "propriétaires".

Avec Mozilla 1.2 et IE 6.0, la norme est maintenant parfaitement implémentée et l'interopérabilité quasi parfaite. On peut donc vraiment faire du XML pour la publication de pages Ouaib sans utiliser de serveurs particuliers ou de parseurs supplémentaires.

Fort de cette constatation, en ce début du mois d'avril 2003, j'ai refait du XML et je vais essayer de refaire petit à petit ce document avec des exemples et les nouveautés.

XML en bref

XML est l'acronyme de eXtensible Makup Language.

On peut voir XML comme une généralisation de HTML ou bien comme une restriction de SGML (Standard Generalized Markup Language). Le but d'XML est de faciliter la création, la distribution des documents SGML sur le Web et d'augmenter l'interopérabilité entre l'HTML et le SGML.

Par construction, un document XML est aussi un document SGML et peut donc être utilisé par un moteur SGML.

En HTML, l'ensemble des balises est fixé ainsi que leurs attributs et les règles d'utilisation. L'XML abolit ces contraintes et est en ce sens un véritable méta-langage (pour décrire des langages à balises).

XML a été développé par le XML Working Group sous l'égide du World Wide Web Consortium (W3C) en 1996.

Les buts (tels que décrits dans la spécification (cf [XML1] ) sont :

• XML doit être facilement utilisable sur Internet,
• XML doit supporter un large panel d'applications,
• XML doit être compatible avec SGML,
• l'écriture de programmes pour l'analyse d'XML ("processeur") doit être facile,
• le nombre de caractéristiques optionnelles de XML doit être réduite au minimum, idéalement zéro.
• les documents XML doivent être intelligible pour l'humain et raisonnablement clairs.
• la conception d'XML doit être préparée rapidement,
• la conception d'XML doit être formelle et concise,
• les documents XML doivent être facile à créer
• la concision des balises n'est pas importante

La spécification d'XML est associée à divers standards :

• UNICODE et ISO/IEC 10646 pour les caractères;
• Internet RFC 1766 pour les balises d'identification de langages/langues,
• ISO 639 pour les code de langages/langues,
• ISO 3166 pour les noms de pays

Le document XML

Un document XML a une structure physique et une structure logique.

Physiquement, un document XML est constitué d'une ou plusieurs unités de stockage appelées entités. Elles ont toutes un contenu et sont identifiées par leur nom (exception faite de l'entité document et du sous-ensemble externe de la DTD). Chaque document XML possède exactement une entité appelée entité document ou encore racine qui est le point de départ du processeur XML et qui contient le document entier (si celui-ci a un contenu).

Ces entités peuvent contenir des données analysables (parsed) ou pas.

Le contenu de l'entité analysable est vu comme un texte de remplacement (voir la notion de texte) et ce texte fait partie intégrale du document. Les données analysables sont soit des chaînes de caractères soit des balises. Les balises décrivent la structure logique du document et le contenu (storage layout) sur lesquels on peut imposer des contraintes.

Une entité non analysable peut contenir du texte ou non. S'il s'agit de texte, celui-ci peut ne pas être du XML. A chaque entité non analysable est associée une notation identifiée par un nom. XML n'impose aucune contrainte sur le contenu d'une entité non analysable si ce n'est que le nom de l'entité ou de la notation doit être accessible à l'application.

Les entité analysables sont appelées par leur nom par un appel d'entité. Les entité non analysables sont appelées par leur nom défini par un attribut ENTITY ou ENTITIES.

Une entité est dite générale quand elle est utilisée dans le document. Une entité est dite paramètre quand elle est utilisée pour la définition de type (dans la DTD). Ces entités utilisent des formes d'appel différentes et sont utilisées dans des contextes différents. Elles occupent aussi des espaces de nommage différents. Ainsi une entité générale et une entité paramètre portant le même nom sont des entités différentes.

Logiquement, le document XML est composé de déclarations, d'éléments, de commentaires, d'appels de caractères, d'instructions de traitement qui sont indiquées par un balisage explicite.

La structure physique et la structure logique doivent s'emboîter proprement (on dit alors que les entités analysables doivent être bien formées).

Document XML bien formé

Un document XML est dit bien formé (well formed) s'il respecte les conditions suivantes :

• si le document possède un entête et au moins un élément,
• il y a un unique élément encore appelé racine, ou entité document sous laquelle sont placées hiérarchiquement toutes les autres entités; les autres entités doivent être correctement organisées,
• si le document respecte toutes les contraintes de bonne formation énoncées dans la spécification,
• si les entité analysables présentes directement ou indirectement dans le document sont aussi bien formées. Pour simplifier, cela signifie qu'il ne peut pas y avoir de "chevauchement" : aucune balise de début ou de fin, aucune balise vide, aucun élément, aucun commentaire, aucune instruction de traitement, aucun appel de caractère ou d'entité ne peut commencer dans une entité et finir dans une autre.

Un document bien formé peut aussi être valide (valid) si celui-ci possède une DTD.

Par la notion de texte, on entend un ensemble constitué de données textuelles(character data) et de balisage.

Le balisage peut prendre la forme de balise ouvrante, fermante ou vide, l'appel d'entités ou de caractères, les commentaires, les délimiteurs de section CDATA, les déclarations de type de document, les instructions de traitement, les déclarations XML, les déclarations de texte

Tout ce qui n'est pas balisage est dit données textuelles.

On ne peut utiliser les caractères & et < que lorsqu'ils servent de délimiteurs pour le balisage. Sinon, il faut faire un appel de caractère ou un appel d'entité.

Tous les appels de caractères peuvent ête précédé par un caractère d'échappement : ainsi &#38; devient &#38#38;

Les commentaires peuvent apparaître partout en dehors de tout balisage. Ils ne font pas partie des données textuelles. L'appel d'entités paramètre n'est pas autorisé dans les commentaires. La syntaxe est la suivante : <!-- le commentaire -->

Pour des raisons de compatibilité, on ne peut pas utiliser le double tiret –- dans le commentaire lui-même.

Les sections CDATA peuvent apparaître partout ou des données textuelles peuvent apparaître. Elles distinguent des chaînes de caractères qui autrement pourraient être considérées comme du balisage.

Elles commencent par <![CDATA[ et se terminent par ]]>.

Exemple : <![CDATA[ <nom> tarzan </nom> ]]>

Entête d'un document

Un document XML doit commencer par un entête qui spécifie la version utilisée.
Exemple : <?xml version="1.0"?>

Dans cet entête, on peut trouver des informations sur le codage de caractères, sur la présence d'une DTD.

Déclaration de type de document et DTD

La déclaration de type de document (document type declaration) permet de contrôler la structure logique du document XML et de réutiliser des entités déjà définies.

Un document XML est dit valide s'il possède une déclaration de type de document et s'il la respecte.

La déclaration de type de document doit apparaître avant le tout premier élément du document.

La déclaration de type de document contient ou désigne des déclarations de balisage, ce qui offre une grammaire pour la classe de documents. Cette grammaire est plus connue sous le nom de définition de type de document (document type definition) ou DTD.

La déclaration du type de document peut pointer sur un sous-ensemble externe, un type spécial d'entité externe, contenant les déclarations de balisage, ou bien pointer directement sur un sous-ensemble interne, ou bien encore les deux à la fois. La DTD d'un document correspond à la prise en compte des deux sous-ensembles (le sous-ensemble interne a priorité sur le sous-ensemble externe).

Une déclaration de balisage peut être une déclaration de type d'élément, une déclaration d'une liste d'attributs, une déclaration d'entité ou une déclaration de notation. Ces déclarations peuvent être contenues entièrement ou en partie dans des entités paramètres. Les déclarations peuvent être constituées de texte de remplacement ou d'entités paramètre. L'appel d'entités paramètre est reconnu partout dans toute la DTD sauf dans les littéraux, les commentaires, les instructions de traitement, le contenu des sections conditionnelles ignorées.

Il y a cinq grand types de contraintes :

1. Contrainte de validité sur le type de l'élément racine : le nom dans la déclaration de type de document doit correspondre au type d'élément de l'entité racine.
2. Contrainte de validité sur l'emboîtement des entités paramètre : le texte de remplacement des entités paramètres doit être correctement agencé avec les déclaration de balisage, c'est-à-dire que si le premier ou le dernier caractère d'une déclaration de balisage est contenu dans le texte de remplacement d'une entité paramètre alors l'autre aussi doit aussi y figurer.
3. Contrainte de bonne formation sur les entités paramètre dans le sous-ensemble interne : dans le sous-ensemble interne de DTD, des appels d'entités paramètre ne peuvent apparaître que là où des déclarations de balisage peuvent apparaître, et non pas à l'intérieur des déclarations de balisage.
4. Contrainte de bonne formation d'un sous-ensemble externe : le sous-ensemble externe s'il existe doit se conformer aux règles de production spécifiques.
5. Contrainte de bonne formation : le texte de remplacement des entités paramètres doit correspondre aux règles de productions du sous-ensemble externe.

ATTENTION : MS IE 5.0 ne semble pas traiter correctement la DTD : dans mon code, j'ai placé une balise avec un contenu mais déclarée EMPTY dans la DTD et je n'ai pas eu de message d'erreur.

Structure logique

Chaque document XML contient un ou plusieurs éléments : les éléments non vides sont délimités par une balise ouvrante et une balise fermante, les éléments vides par un balise d'élément vide.

Chaque élément est repéré grâce à son nom, encore appelé identificateur générique (generic identifier), possède un type et une liste d'attributs. Chaque spécification d'attribut a un nom et un type. XML n'impose aucune contrainte sur le nom exception faite qu'un nom ne peut commencer par les lettres x, m et l quelle que soit la casse.

Soit l'élément suivant : <NOM> Tarzan </NOM>, <NOM> est une balise dite ouvrante alors que </NOM> est une balise fermante. « Tarzan » est le contenu de l'élément. La balise fermante a le même nom que la balise ouvrante, à la différence près que le nom est précédé d'un caractère /.

Contrairement au HTML, toute balise XML doit être obligatoirement fermée. Cela donne une syntaxe particulière pour les éléments vide.
Exemple : <BALISE_UNIQUE/>

Comme en HTML, chaque élément peut avoir des attributs. Ceux-ci se placent uniquement dans les balises ouvrantes ou bien dans les balises vides. Les noms des attributs sont obligatoirement écrits en minuscule et leur valeur est encadrée par des guillemets.
Exemple : <NOM lang="fr"> Tarzan </NOM>

XML par l'exemple

Le document XML

Pratiquement, un document XML est constitué de trois fichiers :

1. un fichier de contenu
2. une feuille de style
3. une feuille facultative de vérification (DTD)

Les trois fichiers cités sont tous des documents XML dans la mesure où ils respectent tous les règles de constructions XML (par exemple, ils commencent tous par un entête qui spécifie la version d'XML utilisée).

Le fichier contenu porte l'extension ".xml", on l'appelle le fichier XML. Il est organisé hiérarchiquement.

<?xml version="1.0" ?>
<FILM>
    <NOM> Tarzan </NOM>
    <ANNEE> 1999 </ANNEE>
    <DISTRIBUTION>
        <PERSONNAGE>
            <NOM> Tarzan </NOM>
            <ACTEUR> acteur1 </ACTEUR>
        <PERSONNAGE>
        <PERSONNAGE>
            <NOM> Jane </NOM>
            <ACTEUR> acteur 2 </ACTEUR>
        <PERSONNAGE>
        <PERSONNAGE>
            <NOM> Singe </NOM>
            <ACTEUR> acteur 3 </ACTEUR>
        <PERSONNAGE>
    </DISTRIBUTION>
</FILM>

L'entité racine est ici l'élément de balise <FILM>.

Pour les règles d'écriture des éléments et leurs attributs, il faut consulter la section "Structure logique".

Dans un fichier XML, on ne s'occupe que du contenu et en aucun cas de la mise en forme.

Celle-ci est décrite dans des fichiers dédiés appelés feuilles de style d'extension ".css" ou ".xsl".

On peut utiliser les feuilles de style CSS définies par HTML ou bien utilisé la nouvelle feuille de style spécifique au XML : XSL ou Extensible StyleSheet Language.

Dans la feuille de vérification ou DTD, on peut y trouver la liste de toutes les balises utilisables avec une description de leurs attributs et le type du contenu.

Dans l'exemple précédent, on sera averti si l'on utilise la balise <NAME> en lieu et place de <NOM>. De même, on pourra fixer le contenu de la balise <ANNEE> pour être sûr que le contenu est bien un nombre.

L'entête d'un fichier XML est de la forme : <?xml version="1.0" standalone="yes" encoding="UTF-8" ?>

Les attributs standalone et encoding sont optionnels. Leurs valeurs par défaut sont celles données dans l'exemple.

L'attribut standalone a la valeur yes si une DTD n'est pas associée au ficher, no sinon.

L'attribut encoding précise le jeu de caractères utilisé (parmi tous ceux que propose la norme unicode). Par exemple :

• UTF-8 : codage des caractères sur 8 bits
• UTF-16 : codage des caractères sur 16 bits
• ISO-8859-1

L'entête <?xml version="1.0" standalone="yes" ?> définit donc un fichier XML sans DTD avec un encodage de caractères par défaut.

L'entête doit aussi préciser où se trouvent la feuille de style et la DTD.

Aller plus loin :

Si dans un fichier XML, on veut utiliser une entité générale, on note celle-ci &nom;.
Si on veut utiliser une entité paramètre, on la note %note;.

DTD

La DTD, si elle existe, doit être placée avant le premier élément du fichier XML.

Si celle-ci est externe, ce qui est le cas le plus courant, on se contentera de donnerle nom du fichier où elle se trouve :
<!DOCTYPE film SYSTEM "film.dtd" > ce qui se traduit par : la DTD de l'élément FILM est dans le fichier externe "film.dtd".

Si la DTD est interne (incluse dans le fichier XML), la syntaxe est la suivante :
<!DOCTYPE film [
<!ELEMENT nom (#PCDATA) >
]>

La DTD peut très vite devenir complexe d'où la nécessité de la commenter. La syntaxe d'un commentaire est la suivante : <!-- commentaires -->

Si l'on veut contraindre le contenu d'une balise, il faut faire une définition d'élément. La syntaxe est la suivante : <!ELEMENT nom type >

Un élément peut être défini comme un groupe d'un ou plusieurs sous-éléments/sous-groupes, comme contenant des données textuelles, vide ou quelconque.

Avec les déclarations suivantes, on définit différents types d'éléments.
<!ELEMENT A EMPTY> : A est un élément vide,
<!ELEMENT B ANY> : B est un élément quelconque,
<!ELEMENT C (#PCDATA)> : C contient des données textuelles,
<!ELEMENT D (E, F)> : D est un ensemble des éléments E et F.

PCDATA signifie Parsed Character DATA ou données textuelles analysables. Cette dénomination est directement issue de SGML.

Les éléments définis comme vide, quelconque ou données textuelles sont dit éléments terminaux du langage. Les élément définis comme groupe sont des éléments non terminaux.

De nombreuses opérations sont possibles pour les éléments non-terminaux.

<!ELEMENT A (B)> : A contient un seul élément B.
<!ELEMENT A (B, C)> : A contient un élément B suivi par un élément C (séquence).
<!ELEMENT A (B | C) > : .A est soit un élément B , soit un élément C (choix de sous-groupe).
<!ELEMENT A (B, (C | D), E> : A est une séquence contenant un choix de sous-groupe.
<!ELEMENT A (B | C | (D, E))> : A est un choix de sous-groupe incluant une séquence.

Différents opérateurs peuvent être appliqués à des sous-éléments, sous-groupes ou groupes, l'opérateur ? pour un groupe optionnel, l'opérateur + pour dire "le groupe est présent au moins une fois), l'opérateur * pour dire "le groupe peut être présent (éventuellement plusieurs fois) ou pas".

<!ELEMENT A (B?, C)> : l'élément B est optionnel.
<!ELEMENT A (B, (C | D)+ , E) > : le groupe (C|D) est présent une ou plusieurs fois.
<!ELEMENT A (B|C)* > : le groupe (B|C) est présent zéro ou plus fois, A peut donc être vide.
<!ELEMENT A (#PCDATA, B)* > : A est dit composé mixte (il contient des données textuelles et un sous-groupe). Le mot-clé #PCDATA doit apparaître en premier.

Un élément peut avoir zéro, un ou plusieurs attributs.

Pour chaque élément, on peut définir une liste d'attributs (simple ou multiple). Pour chaque attribut de la liste, on peut imposer le nom, le type et l'usage.

On va définir deux attributs a et b pour l'élément A. Les deux formulations suivantes sont équivalentes :

Le premier exemple est une liste simple, l'autre est une liste multiple.

Dans le cas général, on a :
<!ATTLIST nom_de_le_liste
    nom_attribut_1 type_attribut usage valeur_par_défaut
    nom_attribut_2 type_attribut usage valeur_par_défaut
    ...
>

Les attributs peuvent être optionnels, obligatoires ou fixés (Ce que j'ai appelé l'usage). Quand un attribut est optionnel, il peut avoir une valeur par défaut. Quand l'attribut est fixé, il a obligatoirement une valeur par défaut, sa valeur... Par défaut, un attribut est optionnel et avec une valeur par défaut. Si la valeur par défaut n'est pas précisée, il faut spécifier le mot-clé #IMPLIED. Un attribut obligatoire se repère par le mot-clé #REQUIRED et Un attribut fixé par #FIXED.

<!ATTLIST A a CDATA #IMPLIED> : a est un attribut optionnel sans valeur par défaut.
<!ATTLIST A a CDATA "a"> : a est un attribut optionnel qui, s'il n'est pas précisé, a pour valeur sa valeur par défaut (la lettre a dans notre exemple).
<!ATTLIST A a CDATA #REQUIRED> : a est un attribut qui doit être obligatoirement être précisé.
<!ATTLIST A a CDATA #FIXED "a"> : a est un attribut fixé, sa valeur est constante (la lettre a dans notre exemple).

Chaque attribut est typé.

Si l'attribut est une chaîne de caractères, on utilise le mot-clé CDATA. La valeur de l'attribut peut aussi appartenir à une simple énumération définie par l'utilisateur.
<!ATTLIST A choix (oui | non) #IMPLIED> : l'attribut choix a deux valeurs possibles : oui ou non.

Un attribut peut aussi être bien plus complexe.

<!ATTLIST A a NOTATION (not1 | not2) #IMPLIED> : l'attribut a est une énumération d'éléments NOTATION.

Les mots-clé ID et IDREF permettent de manipuler des éléments par leurs identificateurs ou ID.
<!ATTLIST A id ID #REQUIRED> : l'attribut id donne l'ID de l'élément A.
<!ATTLIST A ref IDREF #IMPLIED> : l'attribut ref pointe sur l'ID d'un autre élément.

Les mots-clé ENTITY et ENTITIES signifient que l'attribut pointe sur des données externes exprimées sous formes d'entités non analysables.
<!ATTLIST A a ENTITY #IMPLIED> : l'attribut a pointe sur une seule entité non analysable.
<!ATTLIST A a ENTITIES #IMPLIED> : l'attribut a fait référence à plusieurs entités non analysables.

Les attributs qualifiés par NMTOKEN ou NMTOKENS peuvent avoir pour valeur un ou plusieurs symboles (tokens) .
<!ATTLIST A a NMTOKEN #IMPLIED>
<!ATTLIST A a NMTOKENS #IMPLIED>

La déclaration d'une entité paramètre est la suivante :
<!ELEMENT % nom valeur >

Une notation identifie par un nom le format d'une entité non analysable (un chemin d'accès ou une URL par exmple).
<!NOTATION nom PUBLIC valeur>
<!NOTATION nom SYSTEM valeur>

XSL

Pour afficher une page XML, il est nécessaire de disposer d'un système décrivant comment une telle page peut être affichée. Pour cela, on peut utiliser celui développé pour HTML, le CSS ou Cascade Style Sheets, ou lui préférer un nouveau système développé pour XML, le XSL ou eXtensible StyleSheets Language.

XSL est bien plus puissant que CSS : non seulement XSL permet de formater les données XML mais il permet aussi de les filtrer et de les trier.

D'un point de vue théorique, XSL permet de passer de l'arbre source à un arbre résultat (processus dit de transformation encore appelé XSLT) et d'afficher cet arbre résultat (processus dit de formatage). Ainsi la séparation des données et de l'affichage cher à XML est bien respecté.

Pour utiliser une feuille de style XLS avec le fichier XML, il faut préciser dans l'entête du fichier XLM où se trouve la feuille de style :
<?xml-stylesheet type="text/xsl" href="film.xsl"?>

Le fichier XSL est avant tout fichier XML : il a donc un entête qui précise la version d'XML utilisée et le type de fichier.

<?xml version='1.0'?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
   <html>
   <body>
   <xsl:for-each select="FILM/DISTRIBUTION/PERSONNAGE">
       <p>
       <xsl:value-of select="NOM"/> <br/>
       <xsl:value-of select="ACTEUR"/>
       </p>
    </xsl:for-each>
    </body>
    </html>
</xsl:template>
</xsl:stylesheet>

ATTENTION : le XSL tel qu'il est traduit par Internet Explorer 5.0 ou 5.5 n'est pas tout à fait compatible avec la norme du W3C. En effet, à la sortie d'IE 5.0, la norme n'était pas encore complètement définie. Voici l'entête de fichier qu'il fallait utiliser :
                         <xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">

On peut voir le XSL comme un patron (template) HTML pour générer du HTML. Il faut noter que le HTML utilisé dans un fichier XSL n'est pas tout à fait du vrai HTML : le HTML doit être bien formé, c'est-à-dire vérifier les règles de bonne formation du XML : toutes les balises doivent être fermées, les caractères &, < doivent être correctement utilisés (si ces caractères ne sont pas utilisés pour la syntaxe, ils ne peuvent pas se trouver sous cette forme, il faut utiliser des appels d'entités ou des appels de caractères ...)

Toutes les directives XSL ont un nom qui commence par xls.

La ligne <xsl:template match="/"> signifie que les références des noms se fait à partir de la racine du document.
ATTENTION : c'est une des utilisations possible de ce motif. Son utilisation est bien plus puisante.

Dans l'exemple, l'élément xsl:for-each repère les éléments dans le fichier XML et répète un patron pour chacun. L'attribut select décrit l'élément dans le fichier source. La syntaxe pour cet attribut est appelée un motif XSL (XSL pattern) et fonctionne comme un système de fichiers où le caractère / sépare les différents répertoires. L'élément xsl:value-of sélectionne un nœud fils dans la hiérarchie et insère son contenu dans le patron.

XPath

On peut voir le XPath comme le chemin à faire pour trouver un élément. La syntaxe est très proche de celle des systèmes de fichiers UNIX ou MS-DOS.

FILM/DISTRIBUTION/PERSONNAGE en est un : on a tout le cheminement pour atteindre l'élément PERSONNAGE (il n'y aura pas confusion avec un autre élément de même nom mais dans une branche différente..)

On peut utiliser les caractères jokers (*, ?) et on retrouve le point (.) et et le point-point (..). Il y a de nombreuses autres possibilités.

Pour retrouver un attribut, on précédera son nom de l'arobase @. Les crochets permettent de tester les descendants : FILM/DISTRIBUTION/*[NAME]

Tous les exemples dans ce document utilisent une forme rapide d'expression des XPath. Il existe une version étendue.

Tri

Imaginons maintenant que l'on ait envie d'afficher les personnages dans l'ordre alphabétique. XSL fournit l'attribut order-by pour cela. Le motif devient alors : <xsl:for-each select="FILM/DISTRIBUTION/PERSONNAGE" order-by="+NOM">

Le symbole + signifie que l'on veut l'ordre croissant. Si on veut l'ordre décroissant, on utilisera le symbole -.

REMARQUE : Je n'ai pas tester si le + ou - est toujours valide en 2003, un attribut est présent pour changer l'ordre.

Il faut parler de la signification des crochets et de la petite incompatibilité IE/SAXON à ce sujet et comment la contourner.

Filtre

On peut aussi filtrer très facilement des données. Imaginons que l'on ait plusieurs personnages "singe". On peut choisir de n'afficher que ceux-ci :
<xsl:for-each select="FILM/DISTRIBUTION/PERSONNAGE[NOM='Singe']">

Les opérateur de filtrage sont au nombre de quatre : l'égalité =, la différence != , l'inférieur &LT&, le supérieur &GT&.

On peut faire la même chose en n'utilisant plus de filtre mais le motif si <xsl:if> :
<xls:if match=".[NOM='Singe']">
   ...
</xls:if>

On peut faire cette opération avec une structure de choix conditionnel <xsl:choose> :
<xls:choose>
   <xsl:when match=".[NOM='Singe']">
      ...
   </xsl:when> (les motifs when peuvent être répétés avec des conditions différentes)
   <xsl:otherwise>
      ...
   </xsl:otherwise>
</xsl:choose>

Remarque : SAXON n'aime pas cette dernière syntaxe (tirée de la MSDN) mais il existe une autre forme correcte elle-aussi et comprise par IE et SAXON.

Il existe plusieurs méthodes pour afficher un fichier XML et sa feuille de style XSL :

1. faire une référence sur la feuille XSL dans le fichier XML grâce à l'entête.
2. Utiliser du javascript sur le client (browser) ou le serveur avec des composants ActiveX et DOM (cf [XSL2])

XML : inconnu au bataillon ?

Où et quand utiliser XML ?

En ce qui concerne les navigateurs, IE 6.0 et Mozilla 1.2 supportent parfaitement le XML et XSL. Si vous voulez utiliser XML avec un IE de version antérierue, vous aurez des problèmes de compatibilité certains.

XML est déjà présent dans des applications comme format de fichier de données : OpenOffice, Office XP ?.

Il existe aussi de nombreux parseurs pour XML, je ne citerai que le projet Xercès qui existe pour de nombreux langages.

XML et JAVA : SAX

SAXON

SAXON est une librairie d'outils JAVA (qui s'appuie sur JAXP) pour notamment transformer du XML (et XSLT) en HTML. Bien pratique en attendant une généralisation d'XML dans les browsers.

Sur le site de Fabrice (http://lzzb.free.fr), vous pouvez voir des exemples d'utilisation de SAXON (cf [DIV3]). Le XSL de SAXON et de IE ne sont pas tout à fait compatibles mais avec quelques efforts, on peut produire du code compréhensible pour les deux (à cetains entêtes près).

Alternatives/Divers

Il existe aussi une autre possibilité : faire transformer le XML en HTML par le serveur... Allez voir le projet Apache correspondant.

Exemple

Pour voir ce que donnait le XML en 2003, j'ai tapé un début de bibliographie donc je fournis les fichiers comme exemple.

La première bonne surprise est la compatibilité IE 6.0 et Mozilla 1.3. La documentation de référence dont je me suis servi pour mettre mes connaissances à jour est le [XSL4].

Dans la feuille XSL, il y a un peu de javascript. Cela reste limité à la portie congrue car, normalement l'usage du javascript dans la feuille n'est pas préconisé (recharger une page est possible, se déplacer à un endroit avec une balise id ou name, même si elle est désormais dépréciée, aussi mais il faut encorei que je teste le passage de paramètres).

J'ai utilisé de manière intensive la balise apply-template. J'ai systématiquement évité les appels récursifs automatiques avec l'attribut select. Cela m'a évité bien des problèmes.

Je n'ai pas encore écrit la DTD correspondante au modèle de données. Dans la page recherche, il y a un autre exemple concernant un lexique.

Références bibliographiques

[XSL1] Spécification d'XSL : http://www.w3.org/TR/xslt
[XSL2] Introduction au XSL : http://www.xml101.com/xsl/
[XSL3] Page du projet Mozilla : http://www.mozilla.org/projects/xslt/
[XSL4] Tutorial XSLpar Norman Walsh : http://www.nwalsh.com/docs/tutorials/xsl/xsl/

[DIV1] Un site en français sur XML : http://www.citeweb.net/apetitje/xml/ [broken!]
[DIV2] Site de Microsoft : http://msdn.microsoft.com
[DIV3] Site officiel de SAXON : http://saxon.sourceforge.net/