Als Tools für diesen Artikel wird Xalan in der Version 2.7 und als Editor Scite verwendet. Zuerst soll einmal aufgezeigt werden, welche Probleme und Limitationen es in XSLT 1.0 gibt. Zu jedem Problem soll dann, sofern vorhanden, eine entsprechende Lösung angeboten werden.

Der erste dieser Fälle ist das dynamische Referenzieren auf Variablen und Parameter per XPath-Ausdruck. Als Beispiel dient eine Liste von Variablen, deren Namen sich nur durch fortlaufende Nummern im Dokument unterscheiden:

1. <xsl:variable name="position_1">Erste Position</xsl:variable>
2. <xsl:variable name="position_2">Zweite Position</xsl:variable>

Die Annahme, dass man jetzt in einer for-each-Schleife bequem auf diese Variable durch Benutzung der position()-Funktion zugreifen könnte, ist falsch. Prinzipiell kann man keine Variablen-Referenzen zur Laufzeit erstellen. Im vorliegenden Beispiel wäre die naheliegende Lösung, ein externes XML-Dokument mit dem Inhalt der Variablen zu verwenden:

1. <variables>
2. <var name="position_1">Erste Position</var>
3. <var name="position_2">Zweite Position</var>
4. </variables>

In XSLT würde man dann über die document()-Funktion auf dieses XML-Dokument zurückgreifen und entsprechend in der for-each-Schleife darauf zugreifen (Listing 1).

1. Listing 1
2. --------------------------------------------------------------------
3. <!-- Einbinden des externen Dokuments -->
4. <xsl:variable name="varDoc" select="document('variables.xml')/variables"/>
6. ...
8. <!-- Dynamischer Zugriff in einer for-each-Schleife -->
9. <xsl:for-each select="*">
10. <!-- Hier generieren wir unseren dynamischen Variablennamen -->
11. <xsl:variable name="tmpVarName" select="concat('position_', position())"/>
13. <!-- Der Zugriff auf den Inhalt dieser Variablen erfolgt über unser XML -->
14. <xsl:variable name="dynVariable" select="$varDoc/var[@name=$tmpVarName]/text()"/>
16. <!-- Der Inhalt der dynamischen Variablen befindet sich jetzt in $dynVariable und kann von hier aus weiterverwendet werden -->
17. </xsl:for-each>

Zunächst holen wir uns das externe XML-Dokument in eine Variable. Dies geschieht durch die interne Funktion document(DATEINAME), die automatisch die angegebene Datei lädt und in ein eigenes DOM parst, das anschließend in unserer Variablen varDoc enthalten ist. Damit haben wir den vollen Zugriff mittels XSLT und XPath auf unser externes Dokument.

Innerhalb der for-each-Schleife soll nun je nach Position ein anderer Wert in unsere Variable einfließen. Da wir entsprechend die Werte in der Form position_x in unserem XML-Dokument angegeben haben, müssen wir in der Schleife nur noch den Namen zusammenbasteln und das Ganze dann aus unserem externen DOM auslesen. Das Zusammenbauen des Variablen-Namens geschieht durch die concat-Funktion, die einzelne Literals/Strings miteinander verbindet. Dort hängen wir dann noch die aktuelle Position, ermittelt durch die XPath-Funktion position() an. Wichtig ist zu erwähnen, dass die Funktion position() immer von eins zu zählen beginnt. Anschließend greifen wir auf unser externes XML zu, indem wir den Wert per select-Statement auslesen:

1. <xsl:variable name="dynVariable" select="$varDoc/var[@name=$tmpVarName]/text()"/>

Als root geben wir unser externes DOM an, dann selektieren wir das Unterelement var, das den aktuellen Variablennamen im Attribut name trägt; damit haben wir unseren Variablenwert dynamisch ausgelesen. Diese Methode hilft nur weiter, wenn der Inhalt der Variablen statisch ist und nicht erst zur Laufzeit ermittelt wird. In XSLT 1.0 haben wir leider keine Möglichkeit, dynamisch auf eine Variable zuzugreifen.

Variablen und Schleifen

1. Text in der 1. Zeile
2. Text in der 2.Zeile
3. ...
4. Text in der 10. Zeile

In der klassischen Programmiersprache würde man einfach eine Schleife von 1 bis 10 durchlaufen lassen und für jeden Durchlauf eine Textzeile ausgeben lassen. In XSLT müssen wir auf einen Trick zurückgreifen, nämlich auf so genannte Named Templates. Da sich ein Template auch selbst wieder aufrufen kann, können wir damit ein rekursives Template bauen, das wie eine Schleife funktioniert (Listing 2).

1. Listing 2
2. ---------------------------------------------------------------------
3. <xsl:template name="loop">
4. <!-- Parameter für den Schleifendurchlauf -->
5. <xsl:param name="from">0</xsl:param>
6. <xsl:param name="inc">1</xsl:param>
7. <xsl:param name="to"/>
9. <!-- Code, der für jeden Durchlauf ausgeführt wird -->
10. <xsl:text>Text in der </xsl:text>
11. <xsl:value-of select="$from"/>
12. <xsl:text>. Zeile</xsl:text>
14. <!-- Rekursiver Aufruf des Templates -->
15. <xsl:if test="$from<=$to">
16. <xsl:call-template name="loop">
17. <xsl:with-param name="from" select="$from+$inc"/>
18. <xsl:with-param name="inc" select="$inc"/>
19. <xsl:with-param name="to" select="$to"/>
20. </xsl:call-template>
21. </xsl:if>
22. </xsl:template>

Zunächst setzen wir die Standard-Parameter from, inc und to. Diese werden benötigt, um den Begrenzungsrahmen für unsere Schleife festzulegen. Anschließend arbeitet dieses Template die Aktionen ab, die in der Schleife vonstatten gehen sollen. Danach wird getestet, ob die Obergrenze der Schleife schon erreicht wurde. Falls ja, wird die Rekursion abgebrochen und die Schleife damit beendet, falls nein, ruft das Template sich selbst wieder mit den gegebenen Parametern auf, erhöht allerdings den Wert des from-Parameter, damit der nächste Durchlauf von der nächsten Position erfolgt. Damit das Ganze auch dynamisch ist, kann man den Wert, um den erhöht werden soll, auch als Parameter inc angeben. Lässt man ihn weg, wird automatisch um eins erhöht. Der Aufruf der Schleife erfolgt durch das call-template-Element mit den zugehörigen Parametern. Soll die Schleife wie in unserem Beispiel von 1 bis 10 laufen, würde der Aufruf wie folgt aussehen:

1. <xsl:call-template name="loop">
2. <xsl:with-param name="from">1</xsl:with-param>
3. <xsl:with-param name="to">10</xsl:with-param>
4. </xsl:call-template>