Tutoriel Règles XSLT en PDF (Intermédiaire)
Règles XSLT : Ce qu'il faut savoir. Le terme désigne l'ensemble des mécanismes de transformation XML fondés sur les xsl:template et les patterns XPath ; un processeur applique ces règles pour produire un arbre résultat puis le sérialiser. XSLT 1.0 est une recommandation officielle du W3C et constitue la version couverte par ce document. Le guide traite la gestion des espaces de noms, le prologue XML et les étapes d'exécution par un processeur, ainsi que des extraits de feuilles de style et schémas pour la mise en pratique.
🎯 Ce que vous allez apprendre
Structure d'une feuille XSLT et élément racine xsl:stylesheet
Identifier un programme comme document XML, comprendre pourquoi les éléments doivent être qualifiés par l'espace de noms xsl et configurer la sortie via xsl:output. Construction d'une feuille valide et choix du format de sérialisation du document résultat.
Définition et déclenchement des règles avec xsl:template
Différencier l'attribut match (patterns XPath) et name (appel par xsl:call-template). Maîtriser le cycle d'instanciation d'une règle dans un nœud-contexte pour orchestrer l'exécution des templates.
Sélection de nœuds et usages de xsl:apply-templates
Utiliser les sélecteurs select (ex. //NOM, //SEANCE/@ID) et comprendre l'impact sur le nœud‑contexte afin de composer des flux de traitement par enchaînement d'xsl:apply-templates pour produire des structures résultat complexes.
Modularité : xsl:import vs xsl:include
Comprendre la différence de préséance entre xsl:import et xsl:include, l'obligation de placer xsl:import en premier, et les stratégies pour surcharger ou fusionner des règles afin d'organiser des feuilles réutilisables.
Patterns XPath applicables dans match
Appréhender les contraintes des expressions utilisables dans match, les motifs interdits et les limites d'évaluation pour cibler des ensembles de nœuds conformes à la sémantique de la spécification 1.0.
📑 Sommaire du document
- Règles XSLT
- Le document source
- Structure d’un programme XSLT
- L’élément xsl:stylesheet
- Deux types d’éléments
- Principaux éléments de premier niveau
- xsl:import et xsl:include
- Les règles XSLT
Configuration du processeur et exécution des règles
Avant la génération du résultat, le processeur lit le document source et la feuille de style, compile les templates et applique les patterns. L'étape d'exécution inclut la résolution des espaces de noms, l'évaluation des expressions XPath et la sérialisation finale. Vérifier le document attendu et le flux de sortie facilite le débogage : comparer les sorties permet d'identifier les templates non déclenchés ou les sélecteurs incorrects.
Environnements d'exécution et processeurs
Tester les règles peut se faire avec plusieurs implémentations et outils : Processeur XSL (Saxon), libxslt (implémentation courante pour XSLT 1.0) et navigateurs offrant un support limité. L'exécution s'effectue via une API (bibliothèques Java, Python, etc.), en ligne de commande ou au sein d'un navigateur. Contrôler les messages d'erreur du processeur et comparer la sortie à l'attendu permet d'itérer rapidement.
Relation entre XSLT et XSL-FO
XSLT transforme un document XML en un arbre résultat (HTML, XML intermédiaire ou flux d'objets). XSL-FO (Formatting Objects) appartient à la même famille XSL mais se concentre sur la mise en forme et la pagination pour produire des sorties imprimables (PDF, PostScript). On utilise souvent XSLT pour générer un document FO, puis un processeur FO pour la mise en page finale.
Exemple de transformation XML vers HTML
Transformer un élément source <titre> en balise de sortie <h1> : source XML, feuille XSLT et sérialisation HTML attendue.
<programme>
<titre>Introduction XSLT</titre>
</programme><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/programme">
<html><body>
<xsl:apply-templates select="titre"/>
</body></html>
</xsl:template>
<xsl:template match="titre">
<h1><xsl:value-of select="." /></h1>
</xsl:template>
</xsl:stylesheet><html><body>
<h1>Introduction XSLT</h1>
</body></html>Gestion des espaces de noms et prologue XML
La déclaration des noms d'espace est indispensable pour la validité d'une feuille de style : l'attribut xmlns:xsl="http://www.w3.org/1999/XSL/Transform" doit apparaître sur xsl:stylesheet. Le prologue XML (par exemple <?xml version="1.0" encoding="UTF-8"?>) précède l'élément racine et définit l'encodage et la version. Sans déclarations correctes, le processeur ne reconnaîtra pas les éléments XSL et la transformation échouera, empêchant la sérialisation du résultat.
Conformité aux standards W3C et écosystème XSL
Ce document suit la recommandation W3C pour XSLT 1.0 et s'inscrit dans l'écosystème XSL, qui regroupe à la fois les langages de transformation et les spécifications de mise en forme (Formatting Objects). Respecter les normes W3C garantit une compatibilité maximale entre processeurs et outils : utiliser une feuille de style XML conforme facilite les tests croisés sur Saxon, libxslt ou autres processeurs XSL. Les exemples fournis illustrent des pratiques compatibles avec la spécification 1.0 pour la compilation des templates, la gestion des espaces de noms et la sérialisation finale.
💡 Pourquoi choisir ce cours ?
Approche pragmatique centrée sur les règles : extraits de feuilles de style, exemples d'exécution et schémas DOM illustrent l'instanciation et la sérialisation. Rédigé par Marc Giraud, le document met l'accent sur la méthodologie, les cas testables et les bonnes pratiques pour une intégration fiable dans des projets d'intégration XML.
👤 À qui s'adresse ce cours ?
- Public cible : développeurs web et intégrateurs XML qui transforment des documents source en pages HTML ou en flux de données, ainsi que administrateurs de contenu travaillant avec des feuilles de style.
- Prérequis : connaissances de base du XML (syntaxe, prologue et arbres DOM), notions d'XPath et familiarité avec la logique de programmation ; la compréhension d'HTML aide pour la mise en forme du document résultat.
- Syntaxe XML indispensable : balises et enveloppes bien formées, attributs, entités XML, prologue (
<?xml ... ?>), gestion des espaces de noms et règles de validité minimales.
❓ Foire Aux Questions (FAQ)
Quelle est la différence pratique entre xsl:import et xsl:include ? Avec xsl:import, les règles du fichier importé ont une préséance moindre, ce qui permet de surcharger des templates ; xsl:import doit apparaître en premier. xsl:include insère le contenu sans notion de priorité et sert à fusionner sans surcharge.
Quelles expressions XPath peut-on utiliser dans l'attribut match ? L'attribut match accepte des patterns désignant des ensembles de nœuds (par ex. PROGRAMME/SEANCE ou @ID) ; certains axes et expressions non positionnelles ne sont pas évaluables dans un pattern standard.
