Qu'est-ce que l'élément en XML?

l'élément est utilisé avec la balise pour appliquer la règle de transformation définie dans le template.

Dans quel contexte utilise-t-on ?

On utilise dans les transformations XSL pour appliquer des règles de transformation à des éléments XML spécifiques.

xsl:apply-templates XSLT : Guide complet et exemples pratiques 2026

OUJOOD.COM

L'élément `<xsl:apply-templates>` en XSLT

XML / XSLT — Cours et tutoriel

L'élément <xsl:apply-templates> est l'un des mécanismes fondamentaux du langage XSLT (Extensible Stylesheet Language Transformations). Il permet au processeur XSLT de parcourir l'arbre XML et d'appliquer les règles de transformation (templates) appropriées à chaque nœud rencontré. Contrairement à xsl:call-template qui appelle un template nommé explicitement, xsl:apply-templates laisse le moteur XSLT choisir le template le plus adapté selon le pattern XPath défini dans l'attribut match. Cette approche déclarative est au cœur de la puissance de XSLT pour la transformation de documents XML en HTML, en texte ou en d'autres formats XML.

Rôle et fonctionnement de xsl:apply-templates

Placé à l'intérieur d'un élément <xsl:template>, l'élément <xsl:apply-templates> déclenche le traitement des nœuds enfants du nœud courant dans le contexte XPath. Le processeur XSLT analyse chaque nœud enfant et recherche dans la feuille de style XSL le template dont l'attribut match correspond le mieux à ce nœud.

Deux usages principaux existent :

Sans attribut select : <xsl:apply-templates/> traite tous les nœuds enfants dans leur ordre d'apparition dans le document XML source.
Avec l'attribut select : <xsl:apply-templates select="expression-xpath"/> cible uniquement les nœuds correspondant à l'expression XPath spécifiée, permettant aussi de contrôler l'ordre de traitement des nœuds.

Syntaxe officielle de xsl:apply-templates

📋 Copier le code

<xsl:apply-templates
  select = "expression-XPath"
  mode   = "nom-du-mode">
  <!-- Paramètres optionnels transmis au template appelé -->
  <xsl:with-param name="param1" select="valeur"/>
</xsl:apply-templates>

L'attribut mode (optionnel) est particulièrement utile lorsqu'un même nœud XML doit être transformé de différentes façons selon le contexte — par exemple, générer à la fois une table des matières et le corps d'un document à partir d'un même arbre XML source.

Exemple 1 : feuille de style XSL avec xsl:apply-templates

L'exemple suivant illustre une feuille de style XSLT complète qui transforme un catalogue de CD XML en une page HTML structurée. Observez comment les templates se chaînent grâce à xsl:apply-templates avec et sans l'attribut select.

📋 Copier le code

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Template racine : correspond à la racine du document XML ("/") -->
  <xsl:template match="/">
    <html>
      <body>
        <h2>Ma collection de CD</h2>
        <!-- Sans attribut select : traite TOUS les nœuds enfants de la racine
             Le processeur XSLT va parcourir l'arbre et trouver le template
             dont match="catalogue" ou match="cd" correspond -->
        <xsl:apply-templates/>
      </body>
    </html>
  </xsl:template>
  <!-- Template pour chaque élément <cd> du document XML -->
  <xsl:template match="cd">
    <p>
      <!-- Attribut select="title" : applique uniquement le template
           qui correspond à l'élément enfant <title> de <cd> -->
      <xsl:apply-templates select="title"/>
      <!-- Attribut select="artist" : applique le template pour <artist>
           L'ordre ici contrôle l'ordre d'affichage dans le HTML généré -->
      <xsl:apply-templates select="artist"/>
    </p>
  </xsl:template>
  <!-- Template pour l'élément <title> : affiche le titre en rouge -->
  <xsl:template match="title">
    Titre : <span style="color:#ff0000">
      <!-- xsl:value-of select="." récupère la valeur textuelle du nœud courant -->
      <xsl:value-of select="."/>
    </span><br />
  </xsl:template>
  <!-- Template pour l'élément <artist> : affiche l'artiste en bleu -->
  <xsl:template match="artist">
    Artiste : <span style="color:#0000ff">
      <xsl:value-of select="."/>
    </span><br />
  </xsl:template>
</xsl:stylesheet>

Analyse pas à pas de cet exemple :

Le template racine match="/" est toujours exécuté en premier par le processeur XSLT. Il génère la structure HTML de base et délègue le traitement des nœuds enfants via <xsl:apply-templates/> sans attribut.
Le processeur cherche alors un template dont l'attribut match correspond aux enfants de la racine. S'il trouve des éléments <cd>, il applique le template match="cd".
Dans ce template, les deux xsl:apply-templates avec select imposent un ordre d'affichage précis : d'abord le titre (title), puis l'artiste (artist), indépendamment de leur ordre dans le XML source.
Les templates match="title" et match="artist" assurent la mise en forme finale avec des couleurs différentes.

Exemple 2 : utilisation de l'attribut mode pour des transformations multiples

L'attribut mode de xsl:apply-templates permet d'appliquer plusieurs templates différents au même nœud XML. C'est indispensable pour générer, par exemple, un sommaire automatique et le contenu détaillé à partir d'un même document XML.

📋 Copier le code

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <!-- Template racine : génère deux vues du même contenu XML -->
  <xsl:template match="/">
    <html><body>
      <h2>Sommaire</h2>
      <!-- Mode "sommaire" : génère la liste des titres pour la table des matières -->
      <ul><xsl:apply-templates select="catalogue/cd" mode="sommaire"/></ul>
      <h2>Détail de la collection</h2>
      <!-- Mode "detail" : génère le contenu complet pour chaque CD -->
      <xsl:apply-templates select="catalogue/cd" mode="detail"/>
    </body></html>
  </xsl:template>
  <!-- Template mode="sommaire" : affiche uniquement le titre comme item de liste -->
  <xsl:template match="cd" mode="sommaire">
    <li><xsl:value-of select="title"/></li>
  </xsl:template>
  <!-- Template mode="detail" : affiche toutes les informations du CD -->
  <xsl:template match="cd" mode="detail">
    <div>
      <strong><xsl:value-of select="title"/></strong>
      <em> — <xsl:value-of select="artist"/></em>
      <span>Année : <xsl:value-of select="year"/></span>
    </div>
  </xsl:template>
</xsl:stylesheet>

Exemple 3 : contrôle de l'ordre de traitement avec xsl:sort

On peut combiner <xsl:apply-templates> avec <xsl:sort> pour trier les nœuds avant leur traitement — une fonctionnalité très utilisée pour générer des tableaux HTML triés depuis un XML source non ordonné.

📋 Copier le code

<xsl:template match="catalogue">
  <table border="1">
    <!-- apply-templates + xsl:sort : traite les éléments <cd> triés
         par ordre alphabétique croissant sur le contenu de <title> -->
    <xsl:apply-templates select="cd">
      <xsl:sort select="title" order="ascending" data-type="text"/>
    </xsl:apply-templates>
  </table>
</xsl:template>
<xsl:template match="cd">
  <!-- Ce template est appelé pour chaque <cd> dans l'ordre trié -->
  <tr>
    <td><xsl:value-of select="title"/></td>
    <td><xsl:value-of select="artist"/></td>
  </tr>
</xsl:template>

Récapitulatif : fonctionnement du moteur XSLT avec apply-templates

Voici comment le processeur XSLT exécute une transformation avec xsl:apply-templates :

Le moteur XSLT cherche et exécute en premier le template correspondant à la racine (match="/").
Ce template fait appel à d'autres règles, soit implicitement via <xsl:apply-templates/> (tous les enfants), soit explicitement via <xsl:apply-templates select="expression"/> (nœuds ciblés).
Chaque sous-règle applicable est exécutée dans l'ordre XPath des nœuds sélectionnés (ou selon xsl:sort si présent).
Le processeur ne recherche que les templates dont le match correspond aux enfants du nœud de contexte actuel — pas aux frères, ni aux ancêtres.
Si aucun template explicite n'existe pour un nœud, les règles intégrées par défaut du processeur XSLT s'appliquent (propagation du texte pour les nœuds texte, récursion pour les éléments).

Compatibilité et mise à jour 2026

xsl:apply-templates est défini dans les spécifications XSLT 1.0 (W3C, 1999) et XSLT 2.0/3.0. En 2026, les processeurs les plus utilisés restent Saxon (Java, .NET — supporte XSLT 3.0), libxslt (C, PHP, Python — XSLT 1.0), et Xalan (Java — XSLT 1.0). Pour les projets modernes nécessitant des fonctions avancées (groupement, streaming XML, fonctions de haut niveau), privilégiez XSLT 3.0 avec Saxon-HE (version open source). La syntaxe de xsl:apply-templates est identique dans les trois versions de la spécification.