XSL-T / Die XSLT - Struktur / xsl:call-template

xsl:call-template

➪ xsl:call-template ruft benannte Templates (xsl:template name=") auf. Damit eignet sich xsl:call-template gut zur Implementierung von "Unterprogrammen", die durch die eigentlichen "Hauptprogramme" wiederholt aufgerufen werden können.

Auf dieser Seite:

• xsl:call-template
• Rekursive Template-Aufrufe
• Allgemeines zum Thema xsl:call-template

Siehe

• xsl:call-template

Rekursive Template-Aufrufe

Ein möglicher Einsatzzweck für benannte Templates (xsl:template name=") ist die Rekursion, etwa wenn es darum geht, Zwischenschritte einer Berechnung sichtbar zu machen. Das folgende Template berechnet rekursiv die Fakultät der Zahl 10, wobei auch die Zwischenschritte ausgegeben werden (vgl. fold-left). Wichtig dabei ist eine wirksame Rekursionskontrolle, beispielsweise durch xsl:if oder xsl:choose.

<xsl:template name="fakultaet">
    <xsl:param    name="zahl1" as="xs:integer"/>
    <xsl:param    name="zahl2" as="xs:integer"/>
    <xsl:param    name="bis"   as="xs:integer"/>
    <xsl:variable name="produkt" select="$zahl1 * $zahl2"/>
    <wert i="{$zahl1}" produkt="{$produkt}"/>
    <xsl:if test="$zahl1 &lt; $bis">
        <xsl:call-template name="fakultaet">
            <xsl:with-param name="zahl1" select="$zahl1 + 1"/>
            <xsl:with-param name="zahl2" select="$produkt"/>
            <xsl:with-param name="bis" select="$bis"/>
        </xsl:call-template>
    </xsl:if>
</xsl:template>

Aufrufbar wird dieses Template beispielsweise so:

<xsl:template match="/">
    <ergebnis>
        <xsl:call-template name="fakultaet">
            <xsl:with-param name="zahl1" select="1"/>
            <xsl:with-param name="zahl2" select="1"/>
            <xsl:with-param name="bis" select="10"/>
        </xsl:call-template>            
    </ergebnis>
</xsl:template>

Das Resultat sieht dann so aus:

<ergebnis>
   <wert i="1" produkt="1"/>
   <wert i="2" produkt="2"/>
   <wert i="3" produkt="6"/>
   <wert i="4" produkt="24"/>
   <wert i="5" produkt="120"/>
   <wert i="6" produkt="720"/>
   <wert i="7" produkt="5040"/>
   <wert i="8" produkt="40320"/>
   <wert i="9" produkt="362880"/>
   <wert i="10" produkt="3628800"/>
</ergebnis>

Allgemeines zum Thema xsl:call-template

Zur Einordnung von xsl:call-template ist es sinnvoll, sich vorher an die Einsatzbereiche von xsl:for-each select und xsl:template match zu erinnern.

• xsl:for-each select eignet sich hervorragend für stark strukturierte XML-Dokumente. Hier ist es möglich, eine in sich geschlossene Programmlogik ohne gegenseitige Abhängigkeiten konsequent beizubehalten, die sich auch bei größerem Umfang (mehrere Tausend Codezeilen) leichter überblicken und warten lässt.
• xsl:template match bzw. xsl:apply-templates eignet sich für schwächer strukturierte XML-Dokumente, deren Verarbeitung eine höhere Flexibilität erfordert. Damit geht die schrittweise Auslagerung in andere Templates einher: Die gegenseitigen Abhängigkeiten erhöhen sich. Bei größerem Umfang der Programmlogik (insbesondere bei projektübergreifend gemeinsam genutzten Programmteilen) wird der Überblick und das Maintenance erschwert.

Während xsl:template match und xsl:for-each select zur präzisen XPath-Adressierung eine enge Bindung an die Datenstruktur des XML-Inputs erfordern, eignen sich frei benannte Templates (xsl:template name) gut zur Implementierung von "Unterprogrammen", die durch die eigentlichen "Hauptprogramme" beliebig oft aufgerufen (xsl:call-template) werden können. Dies kann weitgehend unabhängig von der Datenstruktur des XML-Inputs geschehen.

Wenn es beispielsweise darum geht, parametergesteuert

• zusätzliche externe XML-Dokumente (außerhalb des XML-Inputs) anzusprechen, diese auszuwerten und die Ergebnisse in den XSL-Transformationsprozess einzubinden,
• Einzelwerte einheitlich abzuarbeiten,

dann ist das ein Fall für xsl:call-template.

Benannte Templates (xsl:template name) erlauben daher,

• die enge Bindung an die Datenstruktur des XML-Inputs weitgehend aufzuheben.
• externe Abhängigkeiten konsequent zu reduzieren und auf diese Weise die Wartbarkeit der Gesamt-Programmierlogik aufrechtzuerhalten.

Zwar ist es möglich, auf jegliche Parameterdefinition zu verzichten und ein benanntes Template mit dem initialen Scope von Elementen/Attributen zu konfrontieren, die dem Template zur Laufzeit übergeben werden (vgl: xsl:variable).

Mit der (vermeidbaren) Gefahr, innerhalb des benannten Templates doch wieder auf die enge Bindung an die Datenstruktur des XML-Inputs zurückzugreifen, um die diversen Elemente/Attribute via XPath gezielt adressieren zu können. In diesem Fall übernimmt xsl:template name die Aufgabe von xsl:template match.

Wird innerhalb eines xsl:template name zudem wiederholt xsl:call-template bzw. <xsl:apply-templates/> aufgerufen, ist der Vorteil schnell dahin, gegenseitige Abhängigkeiten weitgehend vermeiden und die Wartbarkeit des Gesamtsystems erhöhen zu können.

Mehr zum Thema: for-each, apply, call

wg / 22. April 2021

---

---

Fragen? Anmerkungen? Tipps?

Bitte nehmen Sie Kontakt zu mir auf.

---