quelle est la différence entre "call-template" et "apply-templates" dans xsl ?

Question

Je suis nouveau dans Xslt donc je suis un peu confus au sujet des 2 balises,

 <xsl:apply-templates name="nodes"> and <xsl:call-template select="nodes">. 

Pouvez-vous m'indiquer la différence entre les deux ? Merci d'avance.

Answer 1

<xsl:call-template> est un équivalent proche de l'appel d'une fonction dans un langage de programmation traditionnel.

Vous pouvez définir des fonctions dans XSLT, comme cette simple fonction qui produit une chaîne de caractères.

<xsl:template name="dosomething">
  <xsl:text>A function that does something</xsl:text>
</xsl:template>

Cette fonction peut être appelée via <xsl:call-template name="dosomething"> .

<xsl:apply-templates> est un peu différent et c'est en lui que réside la véritable puissance de XSLT : il prend n'importe quel nombre de nœuds XML (ce que vous définissez dans le champ select ), les itère ( ceci est important : apply-templates fonctionne comme une boucle ! ) et trouve les modèles correspondants :

<!-- sample XML snippet -->
<xml>
  <foo /><bar /><baz />
</xml>

<!-- sample XSLT snippet -->
<xsl:template match="xml">
  <xsl:apply-templates select="*" /> <!-- three nodes selected here -->
</xsl:template>

<xsl:template match="foo"> <!-- will be called once -->
  <xsl:text>foo element encountered</xsl:text>
</xsl:template>

<xsl:template match="*"> <!-- will be called twice -->
  <xsl:text>other element countered</xsl:text>
</xsl:template>

De cette façon, vous abandonnez un peu de contrôle au processeur XSLT - ce n'est pas vous qui décidez de l'orientation du flux du programme, mais le processeur qui trouve la correspondance la plus appropriée pour le nœud qu'il est en train de traiter.

Si plusieurs modèles peuvent correspondre à un nœud, celui dont l'expression de correspondance est la plus spécifique l'emporte. S'il existe plus d'un modèle correspondant avec la même spécificité, celui qui est déclaré en dernier l'emporte.

Vous pouvez vous concentrer davantage sur le développement de modèles et consacrer moins de temps à la "plomberie". Vos programmes deviendront plus puissants et modulaires, moins profondément imbriqués et plus rapides (car les processeurs XSLT sont optimisés pour la correspondance des modèles).

Un concept à comprendre avec XSLT est celui du "nœud courant". Avec <xsl:apply-templates> le nœud actuel se déplace à chaque itération, alors que <xsl:call-template> ne modifie pas le nœud actuel. C'est-à-dire que le . dans un modèle appelé fait référence au même nœud que l'élément . dans le modèle appelant. Ce n'est pas le cas avec apply-templates.

C'est la différence fondamentale. Il existe d'autres aspects des modèles qui affectent leur comportement : Leur mode y priority le fait que les modèles peuvent avoir à la fois une name et un match . Cela a également un impact si le modèle a été importé ( <xsl:import> ) ou non. Il s'agit d'utilisations avancées et vous pourrez vous en occuper lorsque vous y arriverez.

Answer 2

Pour ajouter à la bonne réponse de @Tomalak :

Voici quelques différences non mentionnées et importantes :

1. xsl:apply-templates est beaucoup plus riche et profonde que xsl:call-templates et même de xsl:for-each , simplement parce que nous ne savons pas quel code sera appliqué sur les nœuds de la la sélection -- dans le cas général ce code sera différent pour les différents nœuds de la liste de nœuds.

2. Le code qui sera appliqué peut être écrit bien après le xsl:apply template s a été écrit et par des personnes qui ne connaissent pas l'auteur original.

Le site Bibliothèque FXSL L'implémentation de fonctions d'ordre supérieur (HOF) dans XSLT par l'auteur ne serait pas possible. si XSLT n'avait pas le <xsl:apply-templates> l'instruction.

Résumé : Modèles et le <xsl:apply-templates> L'instruction est la façon dont XSLT met en œuvre et traite le polymorphisme.

Référence : Voir tout ce fil : http://www.stylusstudio.com/xsllist/200411/post60540.html

Answer 3

Apply-templates est généralement (mais pas nécessairement) utilisé pour traiter tous les enfants ou un sous-ensemble d'enfants du noeud courant avec tous modèles applicables. Cela permet la récursivité de l'application XSLT qui correspond à la récursivité (possible) du XML traité.

Le modèle d'appel, quant à lui, ressemble beaucoup plus à un appel de fonction normal. Vous exécutez exactement un modèle (nommé), généralement avec un ou plusieurs paramètres.

J'utilise donc apply-templates si je veux intercepter le traitement d'un nœud intéressant et (généralement) injecter quelque chose dans le flux de sortie. Un exemple typique (simplifié) serait

<xsl:template match="foo">
  <bar>
    <xsl:apply-templates/>
  </bar>
</xsl:template>

Alors qu'avec le modèle d'appel, je résous généralement des problèmes tels que l'addition du texte de certains sous-nœuds, la transformation d'ensembles de nœuds sélectionnés en texte ou en d'autres ensembles de nœuds, et ainsi de suite - tout ce pour quoi vous écririez une fonction spécialisée et réutilisable.

Modifier : Comme une remarque supplémentaire à votre texte de question spécifique : <xsl:call-template name="nodes"/> appelle un modèle qui est nommé "nodes" (<xsl:template name="nodes">...</xsl:template>). <xsl:apply-templates select="nodes"/> applique tous les modèles à tous les enfants de votre nœud XML actuel dont le nom est "nodes". C'est une sémantique complètement différente.

Answer 4

La fonctionnalité est en effet similaire (à l'exception de la sémantique d'appel, où l'option call-template nécessite un name et un modèle de noms correspondant).

Cependant, l'analyseur syntaxique ne s'exécutera pas de la même manière.

De MSDN :

Contrairement à <xsl:apply-templates> , <xsl:call-template> ne modifie pas le nœud actuel ou la liste de nœuds actuelle.