XML/XSL/XSLT/Sprachelemente

Den logischen Einstieg in eine XSL-Datei stellt das xsl:stylesheet-Element dar. Das wichtigste Element innerhalb davon ist das xsl:template-Element, mit dessen Hilfe der Ausgangsbaum der XML-Daten in einen Ergebnisbaum einer anderen XML-gerechten Sprache (z. B. auch HTML) übersetzt wird.

Bei den Beschreibungen der Elemente ist häufig von Knoten und Knotentypen die Rede. Diese Begriffe werden im Abschnitt Knoten und Knoten-Sets in der Baumstruktur einführend erläutert. Vertiefende Informationen dazu stehen im Abschnitt über die XPath-Syntax. Denn XPath stellt eine Art von Ergänzungs- oder Hilfssprache innerhalb eines XSLT Stylesheets dar, um unter anderem die Bestandteile eines XML-Dokuments genau zu adressieren. XPath hat, wie XSLT, eine eigene Spezifikation.

Inhaltsverzeichnis

1 xsl:apply-imports (importierte Stylesheets anwenden)
2 xsl:apply-templates (untergeordnete Schablonen anwenden)
3 xsl:attribute (Attribut im Ergebnisbaum erzeugen)
4 Attributwert-Templates (XPath-Ausdrücke inline verwenden)
5 xsl:attribute-set (mehrere Attribute im Ergebnisbaum erzeugen)
6 xsl:call-template (Schablone aufrufen)
7 xsl:choose (Auswahl treffen)
8 xsl:comment (Kommentar setzen)
9 xsl:copy (Element in Ergebnisbaum kopieren)
10 xsl:copy-of (Beliebige ermittelte Daten in Ergebnisbaum kopieren)
11 xsl:decimal-format (Dezimalformat)
12 xsl:element (Element erzeugen)
13 xsl:fallback (alternative Ausführungsanweisung)
14 xsl:for-each (für jedes Element aus einer Menge wiederholen)
15 xsl:if (Wenn-Bedingung)
16 xsl:include (Stylesheets inkludieren)
17 xsl:import (Stylesheets importieren)
18 xsl:key (Schlüssel für Auswahl von Elementen)
19 xsl:message (Meldung beim Transformieren ausgeben)
20 xsl:namespace-alias (Stylesheet in anderes Stylesheet transformieren)
21 xsl:number (fortlaufende Nummerierung)
22 xsl:otherwise (Andernfalls-Anweisung)
23 xsl:output (Erzeugen des Ergebnisbaums kontrollieren)
24 xsl:param (Parameter definieren)
25 xsl:preserve-space (Leerraumzeichen beibehalten)
26 xsl:processing-instruction (Stylesheet-Code generieren)
27 xsl:sort (Elemente nach Inhalt sortieren)
28 xsl:strip-space (Behandlung von Leerraumzeichen steuern)
29 xsl:stylesheet (Stylesheet Wurzelelement)
30 xsl:template (Schablone für Ergebnisbaum definieren)
31 xsl:text (Zeicheninhalt ausgeben)
32 xsl:transform (Stylesheet Wurzelelement)
33 xsl:value-of (Wert ausgeben)
34 xsl:variable (Variable definieren)
35 xsl:when (Bedingung innerhalb einer Auswahl)
36 xsl:with-param (Parameter einen Wert zuweisen)
37 Referenz

xsl:apply-imports (importierte Stylesheets anwenden)

Wendet innerhalb eines mit xsl:template definierten Templates extern definierte Templates an, die mit xsl:import importiert werden.

Erwartet keine Attribute.

Kann nur innerhalb von xsl:template vorkommen.

apply_imports.xml ansehen …

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="apply_imports1.xsl" ?>
<test>
<bild>pinguin.gif</bild>
<text>Der Pinguin ist das Wahrzeichen von Linux</text>
</test>

apply_imports1.xsl

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:import href="apply_imports2.xsl" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:apply-imports/>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

apply_imports2.xsl

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="bild">
<img><xsl:attribute name="src"><xsl:value-of select="." /></xsl:attribute></img>
</xsl:template>

<xsl:template match="text">
<p><xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Im XML-Dokument apply_imports.xml wird das Stylesheet apply_imports1.xsl eingebunden. Dort wird mit Hilfe von <xsl:import href="apply_imports2.xsl" /> ein zweites Stylesheet eingebunden, nämlich apply_imports2.xsl. In der zweiten Stylesheet-Datei stehen Definitionen zur HTML-Umsetzung der Elemente bild und text. Die entsprechenden Definitionen werden im ersten Stylesheet an der Stelle angewendet, an der <xsl:apply-imports/> notiert ist.

xsl:apply-templates (untergeordnete Schablonen anwenden)

Wendet innerhalb eines mit xsl:template definierten Templates andere Templates an, die gegebenenfalls mit xsl:template definiert sind. Auf diese Weise lassen sich Abhängigkeiten und Reihenfolgen bei der Anwendung von Templates steuern.

Hat folgende Attribute:

select: (optional) Wählt ein Template aus, das angewendet werden soll. Angegeben wird das gewünschte Knoten-Set bzw. ein Pfad nach XPath-Syntax. Wenn eine xsl:template-Definition für dieses Element existiert, wird sie angewendet. Fehlt das select-Attribut, werden alle nächstuntergeordneten xsl:template-Definitionen angewendet.
mode: (optional) Wählt das mit select angegebene Template nur dann aus, wenn es den angegebenen Modus hat. Dazu muss bei der xsl:template-Definition mit mode ein übereinstimmender Name für den Modus vergeben sein.

Kann innerhalb von xsl:template vorkommen.

Anzeigebeispiel apply_templates.xml

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="apply_templates.xsl" ?>
<test>
<text>
Was du <zeit>heute</zeit> kannst besorgen, das verschiebe nicht auf <zeit>morgen</zeit>.
</text>
</test>

Anzeigebeispiel apply_templates.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="text">
 <p style="font-family:Tahoma; font-size:18px">
 <xsl:apply-templates />
 </p>
</xsl:template>

<xsl:template match="zeit">
 <i style="color:red">
  <xsl:value-of select="." />
 </i>
</xsl:template>

</xsl:stylesheet>

Im Beispiel-Stylesheet kommt die Anweisung <xsl:apply-templates /> (ohne Attribute) zweimal vor. Zum ersten Mal ist sie in der Template-Definition für die Dokumentwurzel notiert. Dort steht die Anweisung im sichtbaren Bereich des zu erzeugenden HTML-Codes, also zwischen <body> und </body>. Da kein select-Attribut angegeben ist, bewirkt sie, dass an der entsprechenden Stelle des HTML-Codes die Templates für die nächstuntergeordneten Elemente angewendet werden. In der XML-Struktur des Beispiels sind dies Elemente vom Typ text. Für solche Elemente ist mit <xsl:template match="text"> ein Template definiert. Elemente dieses Typs werden in HTML in einen Textabsatz <p>...</p> eingeschlossen, der mit CSS formatiert wird. Für den Inhalt des Textabsatzes gilt jedoch erneut: Template-Definitionen untergeordneter Elemente beachten! Darum ist innerhalb des Textabsatzes wieder die Anweisung <xsl:apply-templates /> notiert. Als untergeordnetes Element von text kann im Beispiel das Element zeit vorkommen. Für dieses Element wird mit <xsl:template match="zeit"> wiederum ein Template definiert. Text in solchen Elementen wird in HTML kursiv und rot dargestellt. Da innerhalb des zeit-Elements keine weiteren, untergeordneten Templates beachtet werden müssen, braucht nur noch der jeweilige Inhalt des Elements beachtet werden. Dies wird durch die Anweisung <xsl:value-of select="." /> bewerkstelligt (siehe auch xsl-value-of).

xsl:attribute (Attribut im Ergebnisbaum erzeugen)

Kann im Ergebnisbaum ein Attribut setzen und mit einem Wert versorgen, also z. B. im HTML-Element div ein Attribut text-align setzen und mit dem Wert center versorgen.

Hat folgende Attribute:

name: (obligatorisch, AWT erlaubt) Gibt den Namen des Attributs an, z. B. align.
namespace: (optional, AWT erlaubt) Gibt den URI des Namensraums an, aus dem das Attribut stammt.

Kann innerhalb von xsl:template oder innerhalb von xsl:attribute-set vorkommen.

Beispieldatei attributes.xml:

Ergebnisdatei attribute.htm

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="attribute.xsl" ?>
<test>
<text ausrichtung="links">
Das ist linksbündiger Text
</text>
<text ausrichtung="zentriert">
Das ist zentrierter Text
</text>
<text ausrichtung="rechts">
Das ist rechtsbündiger Text
</text>
</test>

Beispieldatei attributes.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="text">
 <p>
 <xsl:choose>
  <xsl:when test="@ausrichtung='zentriert'">
   <xsl:attribute name="align">center</xsl:attribute>
  </xsl:when>
  <xsl:when test="@ausrichtung='rechts'">
   <xsl:attribute name="align">right</xsl:attribute>
  </xsl:when>
  <xsl:otherwise>
   <xsl:attribute name="align">left</xsl:attribute>
  </xsl:otherwise>
 </xsl:choose>
 <xsl:value-of select="." />
 </p>
</xsl:template>

</xsl:stylesheet>

Im Beispiel gibt es ein XML-Element text mit dem Attribut ausrichtung, das die Werte links, rechts und zentriert haben kann (laut DTD, im Beispiel weggelassen). In den XML-Daten sind drei Elemente des Typs text notiert, jeweils mit anderem Wert bei ausrichtung. Im Beispiel-Stylesheet wird für Element text mit <xsl:template match="text"> ein Template definiert. Das Template bewirkt, dass Elemente vom Typ text in HTML-Elemente vom Typ p übersetzt werden. Dabei soll jedoch auch die Ausrichtung des Textes berücksichtigt werden. Um zu entscheiden, ob im p-Element das Attribut align den Wert center, right oder left erhalten soll, wird mit den Anweisungen xsl:choose, xsl:when und xsl:otherwise abgefragt, ob das zu übersetzende text-Element der XML-Daten beim Attribut ausrichtung den Wert zentriert, rechts oder links hat. Unterhalb des Abfrage-Komplexes wird schließlich mit der Anweisung <xsl:value-of select="." /> der Inhalt des XML-Elements text in den Inhalt des HTML-Elements p übersetzt.

Attributwert-Templates (XPath-Ausdrücke inline verwenden)

Attribute lassen sich auch ohne den Umweg über das <xsl:attribute> Element mit einem Wert befüllen. Hierfür gibt es die Schreibweise {xpath-ausdruck}, der sich innerhalb von Attributwerten verwenden lässt.

XML Dokument für eine Bildergalerie

<?xml version="1.0" encoding="utf-8"?>
<galerie>
  <bild quelle="pinguin.gif">
    Der Pinguin ist das Wahrzeichen von Linux
  </bild>
</galerie>

XSL Stylesheet Auschnitt zur Erzeugung des <img> Elements

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="bild">
    <img>
      <xsl:attribute name="src"><xsl:value-of select="@quelle" /></xsl:attribute>
      <xsl:attribute name="alt"><xsl:value-of select="normalize-string(.)" /></xsl:attribute>
    </img>
  </xsl:template>

  <xsl:template match="bild">
    <img src="{@quelle}" alt="{normalize-space(.)}" />
  </xsl:template>
</xsl:stylesheet>

Das Beispiel zeigt zwei Varianten des Templates für bild. Natürlich darf ein reales Stylesheet nur eine davon enthalten. Die erste Variante verwendet <xsl:attribute>, um einem <img> Element die Attribute src und alt zuzuweisen. Der Attributwert dazu wird jeweils mit <xsl:value-of> beschafft.

Zum Vergleich zeigt das zweite Template, wie man das Gleiche kürzer mit Attributwert-Templates erledigen kann.

Beachten Sie:

Attributwert-Templates sind in den XML-Elementen, die Ausgabe des Templates sind, in jedem Attribut möglich. Aber auch nur in Attributen - außerhalb davon werden sie nicht beachtet.
Außerdem sind Attributwert-Templates in einigen wenigen Attributen von xsl-Elementen möglich. Das ist bei den jeweiligen Attributen mit "AWT erlaubt" notiert.

xsl:attribute-set (mehrere Attribute im Ergebnisbaum erzeugen)

Definiert ein oder mehrere Attribute für den Ergebnisbaum, und zwar separat. Besonders sinnvoll, um häufig verwendete Attributketten wie border="0" cellpadding="0" cellspacing="0" als Baustein zu definieren, oder um alternative Elementausprägungen durch unterschiedliche Attributbausteine bereitzustellen.

Hat folgende Attribute:

name: (obligatorisch) vergibt einen Namen für das Attribut-Set. Unter diesem Namen kann das Attribut-Set anschließend verwendet werden.
use-attribute-sets: (optional) Bindet andere Attribut-Sets in das aktuelle Attribut-Set mit ein. Anzugeben sind ein oder mehrere Namen von anderen Attribut-Sets. Mehrere Namen werden durch Leerzeichen getrennt.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein. Kann von xsl:element oder xsl:copy über deren Attribut use-attribute-sets innerhalb eines Templates verwendet werden.

Beispieldatei attribute_set.xml

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="attribute_set.xsl" ?>
<test>
 <eintrag>
  <begriff>
   HTML
  </begriff>
  <definition>
   Abkürzung für 'How To Make Love'
  </definition>
 </eintrag>
</test>

Beispieldatei attribute_set.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:attribute-set name="sichtbar">
  <xsl:attribute name="border">1</xsl:attribute>
  <xsl:attribute name="cellpadding">3</xsl:attribute>
  <xsl:attribute name="cellspacing">1</xsl:attribute>
</xsl:attribute-set>

<xsl:attribute-set name="unsichtbar">
  <xsl:attribute name="border">0</xsl:attribute>
  <xsl:attribute name="cellpadding">3</xsl:attribute>
  <xsl:attribute name="cellspacing">1</xsl:attribute>
</xsl:attribute-set>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:element name="table" use-attribute-sets="sichtbar">
 <xsl:for-each select="test/eintrag">
 <tr>
  <td valign="top"><b><xsl:value-of select="begriff" /></b></td>
  <td valign="top"><xsl:value-of select="definition" /></td>
 </tr>
 </xsl:for-each>
 </xsl:element>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Das Beispiel definiert ein Glossar. Die XML-Daten enthalten einen Glossareintrag. Im Beispiel-Stylesheet wird das Glossar in eine HTML-Tabelle umgesetzt. Zu Beginn des Beispielausschnitts und außerhalb der Template-Definitionen werden mit der attribute-set-Anweisung zwei Attribut-Sets definiert, eines mit dem Namen sichtbar, und eines mit dem Namen unsichtbar. Zwischen dem einleitenden Tag <xsl:attribute-set> und seinem Gegenstück </xsl:attribute-set> werden mit Hilfe von xsl:attribute Attribute definiert, die später in den Template-Definitionen verwendet werden können. Im Beispiel handelt es sich um Attribute, die später im table-Element Verwendung finden sollen. Die beiden Attribut-Sets definieren die Attribute so, dass diese die Definition einer Tabelle einmal mit sichtbarem und einmal mit unsichtbarem Rahmen ermöglichen. Innerhalb der Template-Definition, in der die HTML-Tabelle erzeugt wird, wird mit der Anweisung <xsl:element name="table" use-attribute-sets="sichtbar"> das table-Element erzeugt, und zwar mit den Attributen und Werten, die im Attribut-Set mit dem Namen sichtbar definiert wurden.

xsl:call-template (Schablone aufrufen)

Ruft ein anderes Template mit dessen Namen auf. Kann dabei auch Parameterwerte an das aufgerufene Template übergeben.

Hat folgende Attribute:

name: (obligatorisch) der Namen des aufzurufenden Templates, das mit <xsl:template name="..." [...]> definiert sein muss.

Kann innerhalb von xsl:template vorkommen. Kann ohne Inhalt notiert werden oder mit Inhalt und End-Tag. Als Inhalt sind Elemente vom Typ xsl:with-param erlaubt.

Beispieldatei call_template.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="call_template.xsl" ?>
<test>
<kontakt mail="ludo@example.org">Stanislaw Ludowiczy</kontakt>
</test>

Beispieldatei call_template.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template name="Label">
 <xsl:text>, E-Mail-Adresse: </xsl:text>
</xsl:template>

<xsl:template match="kontakt">
 <div>
 <xsl:value-of select="." />
 <xsl:call-template name="Label" />
 <xsl:value-of select="@mail" />
 </div>
</xsl:template>

</xsl:stylesheet>

Das XML-Beispiel enthält Kontaktdaten, wobei im Element kontakt als Inhalt der Name notiert wird, und das Element als Attribut die zugehörige E-Mail-Adresse zugewiesen bekommt. Im Beispiel-Stylesheet wird mit <xsl:template name="Label"> ein Template definiert und benannt. Darin wird mit xsl:text statischer Text definiert. Innerhalb eines anderen Templates, das mit <xsl:template match="kontakt"> definiert wird, ist ein Aufruf des Templates mit dem Namen Label notiert, und zwar in der Anweisung <xsl:call-template name="Label" />. Dadurch wird im Beispiel aus den XML-Daten <kontakt mail="ludo@example.org">Stanislaw Ludowiczy</kontakt> die Ausgabe <div>Stanislaw Ludowiczy, E-Mail-Adresse: ludo@example.org</div> erzeugt.

xsl:choose (Auswahl treffen)

Bildet den Rahmen für eine Reihe von Abfragen, die mit xsl:when und xsl:otherwise durchgeführt werden. Die Reihe kann aus beliebig vielen xsl:when-Abfragen und einer abschließenden xsl:otherwise-Anweisung bestehen. Ausgewählt wird diejenige Abfrage, deren Bedingung als erste zutrifft.

Hat keine Attribute.

Kann innerhalb von xsl:template vorkommen.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei choose.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei choose.xml – XML/XSLT-fähiger Browser erforderlich)

Beispieldatei choose.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="choose.xsl" ?>
<test>
<zahl>69</zahl>
<zahl>12345</zahl>
<zahl>743</zahl>
<zahl>915743</zahl>
</test>

Beispieldatei choose.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <h3>Die Zahlen lauten:</h3>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="zahl">
<div>
<xsl:value-of select="." />
<xsl:variable name="wert" select="." />
 <xsl:choose>
  <xsl:when test="$wert &lt; 10000">
   <xsl:text> (eine kleine Zahl)</xsl:text>
  </xsl:when>
  <xsl:otherwise>
   <xsl:text> (eine gro&szlig;e Zahl)</xsl:text>
  </xsl:otherwise>
 </xsl:choose>
</div>
</xsl:template>

</xsl:stylesheet>

In den XML-Daten des Beispiels werden eine Reihe Zahlen notiert, und zwar jeweils in einem Element namens zahl. Im Beispiel-Stylesheet wird mit <xsl:template match="zahl"> das Template definiert, das die HTML-Ausgabe der Zahlen steuert. Mit <xsl:value-of select="." /> wird der Wert der Zahl ausgegeben (siehe auch xsl-value-of). Anschließend wird eine Variable namens wert definiert, die sich den Wert, also den Inhalt zwischen <zahl> und </zahl>, merkt (siehe auch xsl:variable). Mit <xsl:choose> wird sodann eine Abfragereihe eingeleitet. Sie enthält eine xsl:when-Abfrage und eine xsl:otherwise-Anweisung. Bei der xsl:when-Abfrage wird abgefragt, ob der Wert der Variablen wert kleiner als 10000 ist. Wenn ja, wird hinter die bereits ausgegebene Zahl der Text (eine kleine Zahl) ausgegeben, andernfalls der Text (eine große Zahl). Für die Textausgabe wird xsl:text benutzt.

xsl:comment (Kommentar setzen)

Schließt Ausgaben im Ergebnisbaum in XML- (auch HTML)-gerechte Kommentare ein, sodass der Inhalt nicht ausgegeben wird.

Hat keine Attribute.

Kann innerhalb von xsl:template vorkommen. Beispielauszug aus einem XSL-Stylesheet:

Beispieldatei comment.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<html>
<head>
<script type="text/javascript">
<xsl:comment>
  alert("Hallo Welt");
</xsl:comment>
</script>
</head>
<body>
Hallo Welt
</body>
</html>
</xsl:template>

Im Beispiel-Stylesheet wird bei der HTML-Ausgabe unter anderem ein JavaScript-Bereich notiert. Der Inhalt eines solchen Bereichs sollte, um den Inhalt für nicht-javascript-fähige Browser unzugänglich machen, auskommentiert werden. Im Beispiel wird dies mit Hilfe der xsl:comment-Anweisung realisiert.

xsl:copy (Element in Ergebnisbaum kopieren)

Kopiert einen aktuellen Knoten in den Ergebnisbaum an die Stelle, an der die Anweisung notiert ist. Das ist beispielsweise sinnvoll, wenn die XML-Daten Elemente enthalten, für die es in der Ergebnissprache ein gleichnamiges Element gibt. Es werden die Element-Tags und der PCDATA-Inhalt kopiert, jedoch weder Attribute noch Kindelemente (siehe dazu auch xsl:copy-of).

Hat folgende Attribute:

use-attribute-sets: (optional) Attribute in die Kopie mit einfügen, die mit xsl:attribute-set definiert sind.

Kann innerhalb von xsl:template vorkommen. Kann als Inhalt alles enthalten, was auch innerhalb von xsl:template erlaubt ist.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei copy.htm)

Beispieldatei copy.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="copy.xsl" ?>
<test>
<p>Wenn wir uns für besser halten, sind wir es schon dadurch nicht</p>
<p>Man kann nur Brücken schlagen zwischen Ufern, die man auseinanderhält</p>
</test>

Beispieldatei copy.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <h1>Aphorismen</h1>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="p">
<xsl:copy><xsl:value-of select="." /></xsl:copy>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten des Beispiels bestehen aus Aphorismen, die jeweils in ein XML-Element namens p eingeschlossen sind. Im Beispiel-Stylesheet wird bei der Template-Definition für Elemente des Typs p mit der Anweisung <xsl:copy><xsl:value-of select="." /></xsl:copy> festgelegt, dass sie einfach in den HTML-Ergebnisbaum kopiert werden. Dies ist sinnvoll, da das p-Element in HTML Bedeutung hat und vom Browser entsprechend formatiert wird. Auf diese Weise wird in diesem Fall der gleiche Effekt erreicht, der mit der folgenden Template-Definition erreicht werden würde:

<xsl:template match="p">
<p><xsl:value-of select="." /></p>
</xsl:template>

xsl:copy-of (Beliebige ermittelte Daten in Ergebnisbaum kopieren)

Kopiert einen aktuellen Knoten und das gesamte davon abhängige Knoten-Set in den Ergebnisbaum an die Stelle, an der die Anweisung notiert ist. Das ist beispielsweise sinnvoll, um den Inhalt eines Elements, das nur einmal in den Daten notiert ist, an mehreren Stellen zu wiederholen.

Hat folgende Attribute:

select: (obligatorisch) auswählen, was kopiert werden soll. Dies kann ein Knoten-Set bzw. ein Pfad nach XPath-Syntax sein oder eine Variable.

Kann innerhalb von xsl:template vorkommen. Kann als Inhalt alles enthalten, was auch innerhalb von xsl:template erlaubt ist.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei copy_of.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei copy_of.xml – XML/XSLT-fähiger Browser erforderlich)

Beispieldatei copy_of.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="copy_of.xsl" ?>
<test>
<titel>Telefon</titel>
<telefon><name>Hans</name><nummer>069 - 11727349874</nummer></telefon>
<telefon><name>Sabine</name><nummer>040 - 116343432094</nummer></telefon>
</test>

Beispieldatei copy_of.xsl:

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1"><xsl:apply-templates /></table>
 </body>
 </html>
</xsl:template>

<xsl:template match="titel">
<tr><th colspan="3"><xsl:value-of select="." /></th></tr>
</xsl:template>

<xsl:template match="telefon">
<tr>
<td><xsl:copy-of select="../titel" /></td>
<xsl:apply-templates />
</tr>
</xsl:template>

<xsl:template match="name">
<td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="nummer">
<td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

Das Beispiel definiert eine Telefonliste, bestehend aus Namen und Telefonnummern, mit einer Überschrift, die im Element titel notiert wird. Beim Erzeugen des Ergebnisbaums im Beispiel-Stylesheet wird aus der Telefonliste jedoch eine dreispaltige HTML-Tabelle erzeugt. In der ersten Spalte steht jeweils das Wort Telefon. Dafür sorgt jene Anweisung, die mit <td><xsl:copy-of select="../titel" /></td> den Titel, der eigentlich nur einmal vorkommt, bei jedem Vorkommen des telefon-Elements wiederholt. Die Adressierung des Elements titel erfolgt dabei aus Sicht des Elements telefon nach XPath-Adressierung mit relativen Pfadangaben.

xsl:decimal-format (Dezimalformat)

Definiert ein Schema, in dem Zahlen im Ergebnisbaum ausgegeben werden. In der Funktion format-number() kann dieses Schema angewendet werden.

Hat folgende Attribute:

decimal-separator: (optional) Zeichen, das zwischen Ganzzahl und "Nachkommastellen" steht, um beide Teile zu trennen. Im Deutschen normalerweise ein Komma, im Englischen ein Punkt. Voreinstellung ist der Punkt (.).
digit: (optional) Zeichen, das als Platzhalter für eine unbekannte Ziffer eingesetzt wird. Normalerweise das Gatterzeichen # (Voreinstellung).
grouping-separator: (optional) Zeichen, das eine Gruppe von Zeichen trennt, z. B. als "Tausenderzeichen". Im Deutschen normalerweise ein Punkt, im Englischen ein Komma. Voreinstellung ist das Komma (,).
infinity: (optional) Zeichen oder Zeichenkette, die den Wert für "unendlich" repräsentiert, z. B. bei periodischen Nachkommawerten. Voreinstellung ist Infinity.
minus-sign: (optional) Zeichen, das einem negativen Wert vorangestellt wird. Normalerweise das Minuszeichen – (Voreinstellung).
name: (optional) Name des definierten Schemas. Unter diesem Namen kann das Schema in der Funktion format-number verwendet werden. Wird kein Name angegeben, gelten die Definitionen global.
NaN: (optional) Zeichenkette, die ausdrückt, dass ein Wert keine gültige Zahl ist. Voreinstellung ist NaN (not a number).
pattern-separator: (optional) Zeichen, dass zwischen positiver und negativer Formatdarstellung steht. Voreinstellung ist das Semikolon (;).
per-mille: (optional) Zeichen, mit dem Promillewerte gekennzeichnet werden. Voreinstellung ist %O.
percent: (optional) Zeichen, mit dem Prozentwerte gekennzeichnet werden. Voreinstellung ist das Prozentzeichen %.
zero-digit: (optional) Zeichen für die Darstellung führender Nullen. Voreinstellung ist die Null 0.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei decimal_format.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei decimal_format.xml – XML/XSLT-fähiger Browser erforderlich)

Beispieldatei decimal_format.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="decimal_format.xsl" ?>
<test>
<wert>1230348345</wert>
<wert>17235807</wert>
<wert>12345</wert>
</test>

Beispieldatei decimal_format.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:decimal-format name="de" decimal-separator="," grouping-separator="."/>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="wert">
<div><xsl:value-of select="format-number(.,'#.##0,0','de')" /></div>
</xsl:template>

</xsl:stylesheet>

In den XML-Daten werden einfach diverse Werte notiert, und zwar jeweils in einem Element namens wert. Im Beispiel-Stylesheet wird mit xsl:decimal-format ein Schema für die Formatierung von Zahlen im Ergebnisbaum definiert. Das Schema erhält den Namen de und bestimmt das Komma als Trennzeichen für Ganzzahl und Nachkommastellen sowie den Punkt als Trennzeichen für Tausendergruppen. Für die Ausgabe eines Elements vom Typ wert wird mit <xsl:template match="wert"> ein Template definiert. Jeder Wert wird in einem HTML-Element div ausgegeben. Mit der Anweisung <xsl:value-of select="format-number(.,'#.##0,0','de')" /> wird auf den jeweils aktuellen Inhalt von wert Bezug genommen, und zwar durch Aufruf der Funktion format-number. Diese bekommt in den Klammern als ersten Parameter . übergeben, was für das aktuelle Element steht. Der zweite Parameter ist ein Formatstring, und der dritte Parameter der Name des Schemas, das zuvor mit xsl:decimal-format definiert wurde.

xsl:element (Element erzeugen)

Erzeugt ein Element im Ergebnisbaum. Zwar ist es üblich, Elemente des Ergebnisbaums direkt zu notieren. Doch etwa bei der Anwendung verschiedener Attribut-Sets kann es sinnvoll sein, die Elemente des Ergebnisbaums nicht direkt zu notieren, sondern mit Hilfe von xsl:element zu generieren. Ein anderer Anwendungsfall ist, wenn mit Hilfe von XSL ein Ergebnisbaum erzeugt werden soll, dessen Zielsprache selbst XSL ist.

Hat folgende Attribute:

name: (obligatorisch, AWT erlaubt) Name des zu generierenden Elements, z. B. table für das gleichnamige HTML-Element
namespace: (optional, AWT erlaubt) Namensraum, dem das Element angehört.
use-attribute-sets: (optional) definierte Attribut-Sets, die im einleitenden Tag des zu erzeugenden Elements eingesetzt werden sollen.

Kann innerhalb von xsl:template vorkommen.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei element.htm)

Beispieldatei element.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="element.xsl" ?>
<test>
<produkt><name>Schaukelstuhl</name><preis>99,-</preis></produkt>
<produkt><name>Kaffeemaschine</name><preis>49,95</preis></produkt>
<produkt><name>Schraubenzieher</name><preis>4,95</preis></produkt>
<produkt><name>Sofakissen</name><preis>29,95</preis></produkt>
</test>

Beispieldatei element.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:attribute-set name="grau">
  <xsl:attribute name="bgcolor">#E0E0E0</xsl:attribute>
</xsl:attribute-set>
<xsl:attribute-set name="gelb">
  <xsl:attribute name="bgcolor">#FFFFD0</xsl:attribute>
</xsl:attribute-set>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table>
  <xsl:apply-templates />
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template match="produkt">
 <xsl:choose>
  <xsl:when test="position() mod 2 = 0">
    <xsl:element name="tr" use-attribute-sets="grau">
     <xsl:apply-templates />
    </xsl:element>
  </xsl:when>
  <xsl:otherwise>
    <xsl:element name="tr" use-attribute-sets="gelb">
     <xsl:apply-templates />
    </xsl:element>
  </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template match="name">
 <td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="preis">
 <td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

In den XML-Daten des Beispiels gibt es eine Liste mit Produkten, zu denen jeweils der Name des Produkts und der Preis notiert ist. In der HTML-Ausgabe soll daraus eine Tabelle erzeugt werden, bei der jede zweite Tabellenzeile grau und die übrigen Reihen gelb hinterlegt sind. Dazu werden im Beispiel-Stylesheet mit xsl:attribute-set zwei entsprechende Attribut-Schemata definiert. Da für jedes Produkt eine Tabellenzeile erzeugt werden soll, ist in dem Template, das die HTML-Ausgabe für das Element produkt steuert, eine Abfrage enthalten, ob es sich bei dem jeweils aktuellen Element produkt aus der Datenliste um eine gerade Positionsnummer handelt. Wenn ja, wird die aktuelle Tabellenzeile grau hinterlegt, andernfalls gelb. Die Abfrage wird über die Anweisungen xsl:choose, xsl:when und xsl:otherwise gesteuert. Die Positionsnummer des jeweils aktuellen Elements liefert die Funktion position(). Der Ausdruck mod 2 = 0 fragt, ob die Modulo-Division des Positionswerts 0 ergibt, also keinen Bruchrest erzeugt und somit eine gerade Zahl ist. Abhängig von der Abfrage wird im when-Zweig und im otherwise-Zweig mit xsl:element ein HTML-Element tr Tabellenreihen erzeugt und mit den unterschiedlichen Attribut-Schemata für grau und gelb ausgestattet. Zwischen dem einleitenden Tag und seinem Gegenstück </xsl:element> werden untergeordnete Templates für Namen und Preis des Produkts aufgerufen.

xsl:fallback (alternative Ausführungsanweisung)

Stellt für den XSLT-Prozessor eine Alternativanweisung bereit für den Fall, dass dieser eine nicht so gebräuchliche oder neuere XSLT-Anweisung nicht kennt.

Hat keine Attribute.

Kann innerhalb von xsl:template vorkommen.

Beispieldatei fallback.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="fallback.xsl" ?>
<test>
<text>Es ist egal, ob du A oder B sagst, solange du C nicht kennst.</text>
<text>Worüber man nicht reden kann, darüber soll man schweigen.</text>
</test>

Beispieldatei fallback.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 <xsl:processing-instruction name="xml-stylesheet">
  <xsl:fallback>
   <link rel="stylesheet" href="fallbacktest.css" type="text/css" />
  </xsl:fallback>
  <xsl:text>href="fallbacktest.css" type="text/css" ?</xsl:text>
 </xsl:processing-instruction>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="text">
 <p><xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Im Beispiel-Stylesheet wird mit der Anweisung xsl:processing-instruction ein Stylesheet (CSS) in den HTML-Ergebnisbaum eingebunden. Für den Fall, dass der XSLT-Prozessor diese Anweisung nicht kennt, wird mit xsl:fallback eine Alternative notiert, nämlich die direkte Notation des Befehls zum Einbinden des Stylesheets.

xsl:for-each (für jedes Element aus einer Menge wiederholen)

Stellt eine Schleifenanweisung innerhalb einer Template-Definition dar. Das, was innerhalb der Schleife steht, wird auf alle Knoten innerhalb eines anzugebenden Knoten-Sets angewendet. Alle aufeinanderfolgenden Knoten werden dann der Reihe nach abgearbeitet. So lassen sich beispielsweise alle Elemente listenpunkt, die von einem Element namens liste abhängig sind, direkt innerhalb der Template-Definition für das Element liste abhandeln, ohne dass noch mal eine untergeordnete Template-Definition für das Element listenpunkt aufgerufen werden muss.

Hat folgende Attribute:

select: (obligatorisch) Knoten-Set bzw. Pfad nach XPath-Syntax, für das die Schleife gelten soll.

Kann innerhalb von xsl:template vorkommen.

Beispieldatei for_each.xml:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="for_each.xsl" ?>
<test>
<klasse name="7a">
<schueler>Hans Bentop</schueler>
<schueler>Anika Doll</schueler>
<schueler>Phillip Kleiber</schueler>
</klasse>
</test>

Beispieldatei for_each.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="klasse">
  <h3>Klasse <xsl:value-of select="@name" /></h3>
  <p>
  <xsl:for-each select="schueler">
    <xsl:value-of select="." /><br />
  </xsl:for-each>
  </p>
</xsl:template>

</xsl:stylesheet>

In den XML-Daten des Beispiels werden Schulklassen und ihre Schülernamen notiert. Im Beispiel-Stylesheet wird in dem Template für das Element klasse, das aus beliebig vielen Elementen schueler bestehen kann, mit xsl:for-each eine Schleife erzeugt. Darin wird im Ergebnisbaum der Reihe nach der Inhalt (xsl:value-of) jedes Elements schueler sowie ein Zeilenumbruch erzeugt.

xsl:if (Wenn-Bedingung)

Macht die Ausführung einer Anweisung von einer Bedingung abhängig.

Hat folgende Attribute:

test: (obligatorisch) formuliert die Bedingung.

Kann innerhalb von xsl:template vorkommen.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei if.htm)

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei if.xml - XML/XSLT-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="if.xsl" ?>
<test>
<ergebnis><name>Crystol Freak</name><punkte>453</punkte></ergebnis>
<ergebnis><name>Demian</name><punkte>199</punkte></ergebnis>
<ergebnis><name>Ueberflieger</name><punkte>347</punkte></ergebnis>
<ergebnis><name>CaptainX</name><punkte>106</punkte></ergebnis>
</test>

Beispieldatei if.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:apply-templates />
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template match="ergebnis">
  <xsl:if test="punkte &gt;= 200">
    <tr>
    <xsl:apply-templates />
    </tr>
  </xsl:if>
</xsl:template>

<xsl:template match="name">
 <td><xsl:value-of select="." /></td>
</xsl:template>

<xsl:template match="punkte">
 <td><xsl:value-of select="." /></td>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten im Beispiel enthalten Spielergebnisse, und zwar mit Spielernamen und erreichten Punkten. Im Beispiel-Stylesheet wird daraus eine HTML-Tabelle erzeugt. Es sollen jedoch nur Spieler in der Tabelle erscheinen, die 200 Punkte oder mehr erreicht haben. Dazu wird in dem Template, das die HTML-Ausgabe des XML-Elements ergebnis steuert, mit der Anweisung <xsl:if test="punkte >= 200"> abgefragt, ob der Inhalt des untergeordneten Elements punkte größer oder gleich 200 ist. Wenn ja, wird eine Tabellenzeile erzeugt, und innerhalb davon werden die Templates für die untergeordneten Elemente, also für name und punkte, aufgerufen. Normalerweise würde der Operator für "größer gleich" einfach >= lauten. Weil er aber innerhalb einer XML-basierten Anweisung vorkommt, muss das Größer-als-Zeichen umschrieben werden. Welche Möglichkeiten es für die Formulierung von Bedingungen bei xsl:if gibt, wird im Abschnitt XPath beschrieben.

xsl:include (Stylesheets inkludieren)

XSLT bietet zwei Möglichkeiten um Stylesheets miteinander zu kombinieren. Die erste ist ein Inklusionsmechanismus, der es erlaubt Stylesheets zu kombinieren, wobei die Semantik der kombinierten Stylesheets nicht verändert wird. Die andere Möglichkeit ist ein Importmechanismus, der es Stylesheets erlaubt einander zu überschreiben.

Ein Stylesheet kann andere Stylesheets durch die Benutzung des xsl:include-Elements inkludieren. Das xsl:include-Element ist nur als Element der obersten Ebene erlaubt. Das bedeutet, es kann nur innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Hat folgende Attribute:

href: (obligatorisch) gibt den URI der zu inkludierenden Datei an.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei include.htm)

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei include.xml - XML/XSLT-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="include1.xsl" ?>
<test>
<bild>pinguin.gif</bild>
<text>Der Pinguin ist das Wahrzeichen von Linux</text>
</test>

Beispieldatei include1.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:include href="include2.xsl" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <xsl:apply-templates/>
 </body>
 </html>
</xsl:template>

<xsl:template match="bild">
 <img><xsl:attribute name="src"><xsl:value-of select="." /></xsl:attribute></img>
</xsl:template>

</xsl:stylesheet>

Beispieldatei include2.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="text">
<p><xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Die durch den Wert des href-Attributs angegebene XSL-Datei wird als XML-Dokument analysiert und die Kinder des xsl:stylesheet-Elements in diesem Dokument ersetzen das xsl:include-Element im inkludierenden Dokument. Dass Template-Regel und andere Definitionen inkludiert sind, beeinflusst nicht die Art, wie sie verarbeitet werden.

Beachten Sie: Ein Stylesheet darf weder direkt noch indirekt sich selbst inkludieren. So würde ein <xsl:import href="include1.xsl" /> in der include2.xsl einen Fehler verursachen, denn auf diese Weise würde sich die Datei include1.xsl selbst inkludieren.

xsl:import (Stylesheets importieren)

Importiert Template-Definitionen aus anderen Stylesheet-Dateien, die dann mit xsl:apply-imports an einer gewünschten Stelle angewendet werden können.

Hat folgende Attribute:

href: (obligatorisch) gibt den URI der zu importierenden Datei an.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Beispiel siehe xsl:apply-imports.

Beachten Sie: Im Konfliktfall haben Stylesheet-Definitionen, die in der aktuellen Stylesheet-Datei definiert werden, Vorrang vor importierten Definitionen.

xsl:key (Schlüssel für Auswahl von Elementen)

Definiert einen Zugriffsschlüssel auf Elemente oder Attribute. Dadurch wird dem XSLT-Prozessor die Arbeit erleichtert, was die Verarbeitungsgeschwindigkeit erhöhen kann. Über die Funktion key() kann der Zugriffsschlüssel angewendet werden.

Hat folgende Attribute:

name: (obligatorisch) legt einen Namen für den Schlüssel fest, unter dem er angewendet werden kann.
use: (obligatorisch) gibt an, auf was der Schlüssel zugreifen soll.
match: (optional) gibt das Knoten-Set bzw. einen Pfad nach XPath-Syntax an, an dem der Schlüssel im Elementenbaum ansetzen soll.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei key.htm)

Anzeigebeispiel: (Datei key.xml - XML/XSLT-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="key.xsl" ?>
<test>
<konfig typ="user" name="docroot" wert="/usr/local/web" />
<konfig typ="user" name="cgibin" wert="/usr/local/bin/cgi" />
<konfig typ="expert" name="timeout" wert="60" />
</test>

Beispieldatei key.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:key name="user-only" match="konfig" use="@typ"/>

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:for-each select="key('user-only','user')">
   <tr>
    <td><xsl:value-of select="@name" /></td>
    <td><xsl:value-of select="@wert" /></td>
   </tr>
  </xsl:for-each>
 </table>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten stellen den Inhalt einer Konfigurationsdatei dar. Jeder Konfigurationseintrag, repräsentiert im Element konfig, enthält die Daten in Form von Attributen. Neben den für Konfigurationseinträge typischen Daten name und wert gibt es auch ein Attribut typ, in dem die Werte user und expert zulässig sind. Diese Information könnte beispielsweise helfen, wenn bei der Anzeige der Konfigurationsdaten einem Bearbeiter, der als user angemeldet ist, die Daten des Experten-Modus vorenthalten werden sollen. Das Beispiel-Stylesheet realisiert eine solche Beschränkung. Mit <xsl:key name="user-only" match="konfig" use="@typ"/> wird ein Schlüssel definiert, der auf das Attribut typ zugreift. Zur Anwendung kommt dieser Schlüssel in der Anweisung <xsl:for-each select="key('user-only','user')">. Der Funktion key() wird der Name des zuvor definierten Schlüssels und der gewünschte Attributwert übergeben. Nur Einträge, die diesen Attributwert haben, werden ausgegeben.

xsl:message (Meldung beim Transformieren ausgeben)

Gibt während der Transformation der Daten eine Meldung aus. Wird üblicherweise zur Fehlerbehandlung innerhalb einer Bedingung benutzt.

Hat folgende Attribute:

terminate: (optional) gibt mit yes oder no (Voreinstellung) an, ob der Transformationsvorgang abgebrochen werden soll.

Kann innerhalb von xsl:template vorkommen. Beispieldatei message.xml:

Anzeigebeispiel (Datei message.xml - XML/XSLT-fähiger Browser meldet Message-Fehler)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="message.xsl" ?>
<test>
<lottozahl>32</lottozahl>
<lottozahl>8</lottozahl>
<lottozahl>13</lottozahl>
<lottozahl>40</lottozahl>
<lottozahl>3</lottozahl>
<lottozahl>59</lottozahl>
</test>

Beispieldatei message.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="lottozahl">
  <xsl:variable name="aktuellerwert" select="."/>
  <xsl:if test="$aktuellerwert &gt; 49">
   <xsl:message terminate="yes">
    <xsl:text>Die Zahl (</xsl:text>
    <xsl:value-of select="." />
    <xsl:text>) ist zu gross!</xsl:text><br />
   </xsl:message>
  </xsl:if>
  <xsl:value-of select="." /><br />
</xsl:template>

</xsl:stylesheet>

Im Beispiel sind Lottozahlen notiert. Das Beispiel-Stylesheet formuliert innerhalb der Template-Definition für das Element lottozahl zunächst mit xsl:variable eine Variable und weist dieser den Inhalt des aktuellen Elements zu. Als nächstes wird mit xsl:if geprüft, ob der Inhalt der Variablen größer als 49 ist. Für diesen Fall (Fehlerfall) wird mit xsl:message eine Fehlermeldung konstruiert, die statt der Zahl die Meldung schreibt, dass die betreffende Zahl zu groß ist.

xsl:namespace-alias (Stylesheet in anderes Stylesheet transformieren)

Erlaubt es, ein XSL-Stylesheet in ein anderes XSL-Stylesheet zu transformieren.

Hat folgende Attribute:

stylesheet-prefix: (obligatorisch) gibt den Namen des Namensraums an, der im aktuellen Stylesheet verwendet wird. Dieser Name muss im xsl:stylesheet -Element mit dem Attribut xmlns:[Name] vergeben werden.
result-prefix: (optional) gibt den Namen des Namensraums an, der im Ergebnis-Stylesheet anstelle des Namens verwendet werden soll, der bei stylesheet-prefix angegeben ist.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei namespace_alias.xml)

Anzeigebeispiel(Ergebnisdatei namespace_out.htm - über den Umweg von von output.xsl erzeugt)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="namespace_alias.xsl" ?>
<test>
<gruss>Hallo Welt</gruss>
</test>

Beispieldatei namespace_alias.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:out="namespace_out.xsl">

<xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/>

<xsl:template match="/">
 <out:stylesheet version="1.0">
  <out:template match="/">
   <html><head></head><body>
   <h1><xsl:value-of select="gruss" /></h1>
   <h1><out:text>Hallo Welt - vom Output-Stylesheet</out:text></h1>
   </body></html>
  </out:template>
 </out:stylesheet>
</xsl:template>

</xsl:stylesheet>

Im XML-Teil des Beispiels ist einfach ein Hallo-Welt-Gruß notiert. Im zugehörigen Beispiel-Stylesheet steckt die erste Besonderheit bereits im einleitenden xsl:stylesheet-Element. Dort wird zwei mal das Attribut xmlns notiert: einmal zur Deklaration des üblichen Namensraums (xmlns:xsl="http://www.w3.org/1999/XSL/Transform"), und einmal zur Deklaration eines eigenen Namensraums (xmlns:out="output.xsl"). Durch die Anweisung <xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/> wird dann für den eigenen Namensraum, der den Namen out erhalten hat, festgelegt, dass das aktuelle Stylesheet in das andere Stylesheet (output.xsl) transformiert wird. Das gilt allerdings nur für Notationen, die den Namensraum out angeben. Innerhalb der Template-Definition des Beispiels werden solche Notationen definiert. Die erste beginnt mit <out:stylesheet version="1.0">. Die innere Definition <xsl:value-of select="gruss" /> wird nicht in das Output-Stylesheet übernommen, stattdessen aber <out:text>Hallo Welt – vom Output-Stylesheet</out:text>. Der HTML-Code, der am Ende erzeugt wird, resultiert aus dem, was im Output-Stylesheet definiert ist.

xsl:number (fortlaufende Nummerierung)

Ermöglicht es, sich wiederholende Elemente im Ergebnisbaum mit fortlaufender Nummerierung zu versehen.

Hat folgende Attribute:

count: (optional) bestimmt das oder die Knoten-Sets bzw. Pfade nach XPath-Syntax, bei deren Auftreten der Zähler der Nummerierung erhöht werden soll.
format: (optional, AWT erlaubt) bestimmt die Art der Nummerierung. Folgende Angaben sind möglich:
- 1 = Nummerierung der Art 1, 2, 3, 4 ...
- 01 = Nummerierung der Art 01, 02, 03, 04, ... 10, 11 ...
- a = Nummerierung der Art a, b, c, d ...
- A = Nummerierung der Art A, B, C, D ...
- i = Nummerierung der Art i, ii, iii, iv ...
- I = Nummerierung der Art I, III, III, IV ...

Voreinstellung ist 1. Hinter dieser Angabe zur Art der Nummerierung können noch weitere Zeichen folgen, mit denen die Nummerierung formatiert wird. So bewirkt etwa die Angabe 1., dass hinter der jeweils aktuellen Ordnungszahl noch ein Punkt steht.

from: (optional) bestimmt das Knoten-Set bzw. einen Pfad nach XPath-Syntax, bei dessen Auftreten die Nummerierung begonnen werden soll.
grouping-separator: (optional, AWT erlaubt) Trennzeichen für Zifferngruppen bei hohen Zahlen, z. B. Tausender-Trennzeichen. In der deutschen Schreibweise von Zahlen üblicherweise ein Punkt (.).
grouping-size: (optional, AWT erlaubt) Anzahl der Ziffern, bei der ein Trennzeichen gesetzt wird. Bei Tausender-Trennzeichen wäre das der Wert 3.
lang: (optional, AWT erlaubt) gibt die Sprache (nach RFC 1766) an, nach dessen Sprachkonventionen die Nummerierung erfolgen soll. Anzugeben sind Kürzel der Art de (für deutsch), en (für englisch), fr (für französisch).
letter-value: (optional, AWT erlaubt) erlaubte Werte sind alphabetical oder traditional. Eine Angabe, die zusätzlich zu lang für einige Sprachen sinnvoll ist.
level: (optional) erlaubte Werte sind single, multiple oder any. Die Angabe bezieht sich darauf, was bei count angegeben wird.
- single bedeutet: der Nummerierungs-Algorithmus arbeitet flach auf der aktuellen Ebene des Elementenbaums und kann Nummerierungen der Sorte 1, 2, 3 erzeugen. Passt der aktuelle Knoten auf die Angabe bei count, wird er nummeriert.
- multiple bedeutet: der Nummerierungs-Algorithmus arbeitet hierarchisch über die aktuelle und alle übergeordneten Ebenen des Elementenbaums und kann Nummerierungen der Sorte 1.1 oder 1.1.1 erzeugen. Passt der aktuelle Knoten auf die Angabe bei count, wird er nummeriert. Dabei wird für jede übergeordnete Ebene im Elementenbaum ermittelt, ob die Angabe bei count auf einen Knoten zutrifft. Aus diesen Informationen wird die hierarchische Nummerierung erzeugt. Bei multiple sollte bei count die Sequenz derjenigen Knoten angegeben werden, für die die hierarchische Nummerierung gelten soll. Dies ist durch eine Angabe wie z. B. count="kapitelueberschrift|abschnittsueberschrift|unterueberschrift" möglich. Die Elementnamen werden dabei durch Senkrechtstriche (|) voneinander getrennt. Beim Attribut format sollte in diesem Fall so etwas wie z. B. format="1.1" notiert werden.
- any bedeutet: der Nummerierungs-Algorithmus arbeitet flach über die aktuelle und alle Ebenen des Elementenbaums und kann Nummerierungen der Sorte 1, 2, 3 erzeugen. Passt der aktuelle Knoten auf die Angabe bei count, wird er nummeriert. Dabei wird für jede übergeordnete Ebene im Elementenbaum ermittelt, ob die Angabe bei count auf einen Knoten zutrifft. Die Nummerierung zählt alle Knoten zusammen.
value: (optional) Kalkulationsausdruck, der die Nummerierung bestimmt. Eine mögliche Angabe ist z. B. value="position()".

Kann innerhalb von xsl:template vorkommen.

Anzeigebeispiel (Datei number.xml - XML/XSLT-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="number.xsl" ?>
<test>
<link>http://aktuell.de.selfhtml.org/</link>
<link>http://alpentouren.at/</link>
<link>http://fr.selfhtml.org/</link>
</test>

Beispieldatei number.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="link">
 <xsl:number level="single" count="link" format="1. " />
 <a><xsl:attribute name="href"><xsl:value-of select="." /></xsl:attribute>
 <xsl:value-of select="." /></a><br />
</xsl:template>

</xsl:stylesheet>

Die XML-Daten im Beispiel enthalten eine Reihe von Links, die bei der HTML-Ausgabe durchnummeriert werden sollen. Das Beispiel-Stylesheet wendet zu diesem Zweck innerhalb der Template-Definition für das link-Element zu Beginn des zu erzeugenden HTML-Codes die xsl:number-Anweisung an. Es soll eine einfache Nummerierung durchgeführt werden (level="single"). Die Nummerierung soll bei jedem Auftreten des link-Elements fortgesetzt werden (count="link"). Die Nummerierung soll in der Form 1. ..., 2. ..., 3. ... erscheinen (format="1. "). Anschließend wird innerhalb der Template-Definition ein HTML-Link erzeugt, der den Inhalt des jeweiligen link-Elements in eine im Browser anklickbare Form bringt.

xsl:otherwise (Andernfalls-Anweisung)

Bestimmt, was getan werden soll, wenn eine oder mehrere xsl:when-Bedingungen nicht zutreffen.

Hat keine Attribute.

Kann innerhalb von xsl:choose vorkommen. Beispiel siehe dort.

xsl:output (Erzeugen des Ergebnisbaums kontrollieren)

Gibt an, wie der Ergebnisbaum ausgegeben bzw. geschrieben werden soll.

Hat folgende Attribute:

cdata-section-elements: (optional) bei method="xml": bestimmt Elemente, deren Inhalt beim Erzeugen des Ergebnisbaums in CDATA-Abschnitte geschrieben werden (vergleiche CDATA-Abschnitte). Es können mehrere Elemente angegeben werden, die durch Leerzeichen zu trennen sind.
doctype-public: (optional) bei method="xml" und method="html": wenn sich die Gültigkeitsüberprüfung des Ergebnisbaums auf eine öffentliche DTD-Zuordnung (public identifier) bezieht, erhält dieses Attribut als Wert die Zeichenkette des public identifiers.
doctype-system: (optional) bei method="xml" und method="html": wenn sich die Gültigkeitsüberprüfung des Ergebnisbaums auf eine adressierte DTD-Zuordnung (system identifier) bezieht, erhält dieses Attribut als Wert die Zeichenkette des system identifiers.
encoding: (optional) bestimmt, mit welcher Codierung der Ergebnisbaum kodiert wird. Sinnvoll ist eine Angabe nach RFC 2978.
indent: (optional) kann die Werte yes oder no haben. Bei yes wird der Ergebnisbaum so formatiert, dass untergeordnete Elemente weiter eingerückt werden. Dies hat keine Auswirkung auf die Darstellung, sondern ist eine "kosmetische" Angabe zur besseren Lesbarkeit des erzeugten Quelltextes. Die Voreinstellung für dieses Attributs ist bei method="html" yes, bei method="xml" no.
media-type: (optional) gibt den MIME-Typ des Ergebnisbaums an. Bei method="xml" ist beispielsweise text/xml sinnvoll, bei method="html" beispielsweise text/html und bei method="text" beispielsweise text/plain.
method: (optional) gibt an, nach welcher Art der Ergebnisbaum erzeugt werden soll. Mögliche Werte sind xml, html (Voreinstellung), text, oder bestimmte, eigene oder öffentliche XML-Namensräume.
omit-xml-declaration: (optional) bestimmt bei method="xml", ob im Ergebnisbaum eine XML-Deklaration (<?xml ...?>) ausgegeben werden soll oder nicht. Mögliche Werte sind yes für nein (omit = weglassen) oder no für ja (nicht weglassen).
standalone: (optional) bestimmt bei omit-xml-declaration="no", dass sich die DTD-Deklarationen in der aktuellen Datei befinden (vergleiche Seite Zusätzliche Angaben zur Zeichencodierung und zum DTD-Bezug)
version: (optional) bestimmt bei omit-xml-declaration="no" die XML-Versionsangabe.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein.

Anzeigebeispiel (Ergebnisdatei output_en.xml - XML-fähiger Browser erforderlich, der die Datenstruktur anzeigt)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="output.xsl" ?>
<test>
<ereignis>
  <beschreibung>HH XY 1204 mit Tempo 95 in Zone 70</beschreibung>
  <zeitstempel>13.05.2001,22:25</zeitstempel>
</ereignis>
</test>

Beispieldatei output.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="xml" indent="yes" encoding="utf-8" omit-xml-declaration="yes" />

<xsl:template match="/">
 <test-en>
  <xsl:apply-templates />
 </test-en>
</xsl:template>

<xsl:template match="ereignis">
 <event>
  <xsl:apply-templates />
 </event>
</xsl:template>

<xsl:template match="beschreibung">
 <description><xsl:value-of select="." /></description>
</xsl:template>

<xsl:template match="zeitstempel">
 <timestamp><xsl:value-of select="." /></timestamp>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten im Beispiel enthalten "Ereignisse", wie sie eine Blitzanlage im Straßenverkehr aufzeichnen könnte. Die Elementnamen sind dabei deutschsprachig. In einer XSL-gesteuerten Transformation sollen diese Daten in eine analoge XML-Datei mit gleichem Elementenbaum-Aufbau gebracht werden, deren Elementnamen jedoch englisch sind. In der xsl:output-Anweisung, die im Beispiel-Stylesheet vor den Template-Definitionen steht, wird dem XSL-Parser mitgeteilt, dass der Ergebnisbaum eine XML-Struktur sein soll (method="xml"). Mit indent="yes" wird die saubere Formatierung des XML-Quelltextes der Ausgabe geregelt, und mit encoding="utf-8" die Codierung angegeben. Damit die XML-Ausgabe eine Dokumenttyp-Deklaration und eine Verarbeitungsanweisung erhält, wird mit omit-xml-declaration="yes" die XML-Deklaration veranlasst. In den nachfolgenden Template-Definitionen wird der Datenbaum des Ausgangsdokuments mit den deutschsprachigen Elementnamen in den Ergebnisbaum mit den englischsprachigen Elementnamen übersetzt.

xsl:param (Parameter definieren)

Definiert einen Parameter zur Verwendung mit xsl:with-param .

Hat folgende Attribute:

name: (obligatorisch) gibt den Namen der Parametervariablen an. Unter diesem Namen kann auf ihren Wert zugegriffen werden.
select: (optional) bestimmt einen Default-Wert für die Parametervariable. Wenn dieses Attribut angegeben wird, handelt es sich um einen Parameter, der dazu gedacht ist, von einer Template-Definition an eine andere übergeben zu werden.

Kann innerhalb von xsl:stylesheet vorkommen und kann sowohl außerhalb als auch innerhalb von xsl:template notiert sein. Wenn außerhalb notiert, ist es eine globale Variable, die in allen Template-Definitionen zur Verfügung steht. Wenn innerhalb einer Template-Definition notiert, ist es eine lokale Variable innerhalb des Templates.

Beispiel siehe xsl:with-param.

xsl:preserve-space (Leerraumzeichen beibehalten)

Bestimmt, dass Leerraumzeichen, die zwischen Elementen in der Datei enthalten sind, bei der Ausgabe beibehalten werden. Leerraumzeichen sind die Zeichen mit den Hexadezimalwerten #x20 (einfaches Leerzeichen), #x9 (Tabulator-Zeichen), #xD (Wagenrücklaufzeichen) und #xA (Zeilenvorschub-Zeichen). Es handelt sich nicht um den Textinhalt von Elementen, sondern um die Formatierung der Elemente im Ergebnisbaum.

Hat folgende Attribute:

elements: (obligatorisch) Namen von einem oder mehreren Elementen der Ausgangsdaten, deren Leerraumzeichen in der Ausgabe beibehalten werden soll. Mehrere Angaben sind durch Leerzeichen zu trennen.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein. Beispieldatei preserve_space.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei preserve_space.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei preserve_space.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="preserve_space.xsl" ?>
<test>


<kontakt>Hannes Breuer, breuer@example.org</kontakt>


<kontakt>Eleonore Bleibtreu, elblei@example.org</kontakt>


</test>

Beispieldatei preserve_space.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:preserve-space elements="test" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body><pre>
  <xsl:apply-templates />
 </pre></body>
 </html>
</xsl:template>

<xsl:template match="kontakt">
  <b><xsl:value-of select="." /></b>
</xsl:template>

</xsl:stylesheet>

In den notierten XML-Daten ist zwischen den Elementen innerhalb des Dokument-Elements test Leerraum notiert. Im Beispiel-Stylesheet wird durch die Anweisung <xsl:preserve-space elements="test" /> sichergestellt, dass diese Leerräume bei der Ausgabe erhalten bleiben. In der Template-Definition für die Dokumentwurzel wird der Inhalt dann für die HTML-Ausgabe in das pre-Element eingeschlossen, damit die Leerräume in HTML auch zum Tragen kommen.

xsl:processing-instruction (Stylesheet-Code generieren)

Erzeugt im Ergebnisbaum eine Seite Verarbeitungsanweisung.

Hat folgende Attribute:

name: (obligatorisch, AWT erlaubt) bestimmt den Namen der Verarbeitungsanweisung.

Kann innerhalb von xsl:template vorkommen. Beispieldatei processing_instruction.xml:

Anzeigebeispiel (Ergebnisdatei processing.xml - XML/CSS-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="processing_instruction.xsl" ?>
<test>
<text>guten Tag!</text>
<text>und auf Wiedersehen!</text>
</test>

Beispieldatei processing_instruction.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="xml" Ergebnisbaumxml-declaration="no" />

<xsl:template match="/">
<xsl:processing-instruction name="xml-stylesheet">
 <xsl:text>href="processing.css" type="text/css"</xsl:text>
</xsl:processing-instruction>
 <test>
  <xsl:apply-templates />
 </test>
</xsl:template>

<xsl:template match="text">
 <xsl:copy-of select="." />
</xsl:template>

</xsl:stylesheet>

Beispieldatei processing.css:

text { font-size:21px; color:blue; }

Das XSLT-Stylesheet erzeugt eine neue XML-Datei, in die alle Daten der Input-Datei, im Beispiel also von processing_instruction.xml kopiert werden. Dazu dient einerseits die xsl:output-Anweisung, mit der die XML-Deklaration für die neue XML-Datei erzeugt wird, und andererseits das Kopieren der text-Elemente mit Hilfe von xsl:copy-of in den Ergebnisbaum, also die neue XML-Datei. Der Unterschied der neu erzeugten XML-Datei zur alten ist, dass sie eine Verarbeitungsanweisung zum Einbinden eines Stylesheets erhält. Dazu ist zu Beginn der Template-Definition für die Dokumentwurzel / ein xsl:processing-instruction-Element mit Namen xml-stylesheet notiert, das eine externe CSS-Datei einbindet. Das hat zur Folge, dass die XML-Daten direkt mit den Formaten aus der eingebundenen CSS-Datei ausgegeben werden. Im Ergebnisbaum wird die Prozessoranweisung wie folgt umgesetzt:

<?xml-stylesheet href="ausgabe.css" type="text/css" ?>code>

Die Attribute werden im Beispiel zwischen einleitendem und schließenden Tag von xsl:processing-instruction mit xsl:text notiert.

xsl:sort (Elemente nach Inhalt sortieren)

Sortiert Knoten aus einer Reihenfolge nach ihren Inhalten. So lassen sich beispielsweise alle untergeordneten Elemente listenpunkt eines Elements namens liste bei der Transformation alphabetisch oder numerisch sortieren.

Hat folgende Attribute:

case-order (optional, AWT erlaubt) bestimmt, ob in der Sortierung Großbuchstaben vor Kleinbuchstaben kommen oder umgekehrt. Mögliche Werte sind upper-first (Großbuchstaben zuerst) oder lower-first (Kleinbuchstaben zuerst, Voreinstellung bei data-type="text").
data-type (optional, AWT erlaubt) bestimmt, ob die Sortierung alphabetisch (Voreinstellung) oder numerisch erfolgen soll. Bei alphabetischer Sortierung kommt z. B. 9 nach 10, bei numerischer 10 nach 9. Mögliche Werte sind text (alphabetische Sortierung) oder number (numerische Sortierung).
lang (optional, AWT erlaubt) gibt die Sprache (nach Seite RFC 1766) an, nach dessen Sprachkonventionen die Sortierung erfolgen soll. So wird beispielsweise der Buchstabe ä im Deutschen (lang="de") anders im Alphabet eingeordnet als im Schwedischen (lang="se").
select (optional) gibt an, was sortiert werden soll. Wird das Attribut weggelassen, ist der Inhalt des betroffenen Elements dasjenige, was sortiert wird.
order (optional, AWT erlaubt) bestimmt, ob die Sortierung aufsteigend (Voreinstellung), also etwa von A nach Z, oder absteigend, also etwa von Z nach A, erfolgen soll. Mögliche Werte sind ascending (aufsteigende Sortierung) oder descending (absteigende Sortierung).

Kann innerhalb von xsl:apply-templates oder xsl:for-each vorkommen. Beispieldatei sort.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei sort.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei sort.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="sort.xsl" ?>
<test>
<spieler><name>Fridolin</name><punkte>12</punkte></spieler>
<spieler><name>Paolo</name><punkte>19</punkte></spieler>
<spieler><name>Richie</name><punkte>27</punkte></spieler>
<spieler><name>Winnie</name><punkte>10</punkte></spieler>
</test>

Beispieldatei sort.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:for-each select="test/spieler">
   <xsl:sort select="punkte" order="descending" data-type="number" />
   <tr>
   <td><xsl:value-of select="name" /></td>
   <td><xsl:value-of select="punkte" /></td>
   </tr>
  </xsl:for-each>
 </table>
 </body>
 </html>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten im Beispiel enthalten Spielernamen und erreichte Punktzahlen. Bei der HTML-Ausgabe wird diese Liste nach Punktzahlen absteigend sortiert. Dazu wird im Beispiel-Stylesheet innerhalb der xsl:for-each-Anweisung eine xsl:sort-Anweisung notiert. Die Anweisung wirkt an dieser Stelle notiert wie ein Filter, der die Abarbeitung der einzelnen Elemente vom Typ spieler beeinflusst. Als Sortierkriterium wird punkte angegeben, da nach Punktzahlen sortiert werden soll. Die Sortierreihenfolge soll absteigend (descending) sein. Da die Punktzahlen numerisch interpretiert werden sollen, ist noch die Angabe data-type="number" notiert. Anschließend werden einfach die aktuellen Werte der Elemente name und punkte in die HTML-Tabelle geschrieben.

xsl:strip-space (Behandlung von Leerraumzeichen steuern)

Bestimmt, dass Leerraumzeichen, die zwischen Elementen in der Datei enthalten sind, bei der Ausgabe entfernt werden. Leerraumzeichen sind die Zeichen mit den Hexadezimalwerten #x20 (einfaches Leerzeichen), #x9 (Tabulator-Zeichen), #xD (Wagenrücklaufzeichen) und #xA (Zeilenvorschub-Zeichen). Es handelt sich nicht um den Textinhalt von Elementen, sondern um die Formatierung der Elemente im Ergebnisbaum.

Hat folgende Attribute:

elements: (obligatorisch) Namen von einem oder mehreren Elementen der Ausgangsdaten, deren Leerraumzeichen in der Ausgabe entfernt werden sollen. Mehrere Angaben sind durch Leerzeichen zu trennen.

Kann innerhalb von xsl:stylesheet vorkommen und muss außerhalb von xsl:template notiert sein. Beispieldatei strip_space.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei strip_space.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei strip_space.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="strip_space.xsl" ?>
<test>


<kontakt>Hannes Breuer, breuer@example.org </kontakt>


<kontakt>Eleonore Bleibtreu, elblei@example.org</kontakt>


</test>

Beispieldatei strip_space.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:strip-space elements="test" />

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body><pre>
  <xsl:apply-templates />
 </pre></body>
 </html>
</xsl:template>

<xsl:template match="kontakt">
  <b><xsl:value-of select="." /></b>
</xsl:template>

</xsl:stylesheet>

In den notierten XML-Daten ist zwischen den Elementen innerhalb des Dokument-Elements test Leerraum notiert. Im Beispiel-Stylesheet wird durch die Anweisung <xsl:strip-space elements="test" /> sichergestellt, dass diese Leerräume bei der Ausgabe entfernt werden. In der Template-Definition für die Dokumentwurzel wird der Inhalt dann für die HTML-Ausgabe in das pre-Element eingeschlossen, damit das Verschwinden der Leerräume in HTML sichtbar wird.

xsl:stylesheet (Stylesheet Wurzelelement)

Ist das Wurzelelement eines XSL-Stylesheets und beinhaltet sämtliche Style-Definitionen.

Hat folgende Attribute:

extension-element-prefixes: (optional) gibt Namensräume an, die innerhalb des Stylesheets benötigt werden, um Elemente dieser anderen Namensräume zu erkennen. Erlaubt sind eine oder mehrere Angaben. Mehrere Angaben sind durch Leerzeichen zu trennen.
exclude-result-prefixes: (optional) gibt Namensräume an, die innerhalb des Stylesheets benötigt werden, um Elemente dieser anderen Namensräume zu erkennen. Beim Erzeugen des Ergebnisbaums werden diese Namensräume jedoch nicht mit übernommen, sofern sie dort nicht benötigt werden. Erlaubt sind eine oder mehrere Angaben. Mehrere Angaben sind durch Leerzeichen zu trennen.
id: (optional) legt einen eindeutigen Bezeichnernamen für das Stylesheet fest, unter dem es "von außen" ansprechbar ist.
version: (obligatorisch) gibt die verwendete XSL-Sprachversion an. Diese unbedingt erforderliche Angabe muss derzeit 1.0 lauten.

Ferner enthält das xsl:stylesheet-Element eine oder mehrere Angaben darüber, welchen Namensraum es benutzt. Dazu müssen die Quellen der Namensräume mit xmlns:xsl=[Quelle] angegeben werden. Für den XSLT-Namensraum ist üblicherweise xmlns:xsl="http://www.w3.org/1999/XSL/Transform" anzugeben. Abweichungen dazu sind abhängig vom verwendeten XSL-Prozessor. Beispieldatei stylesheet.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei stylesheet.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei stylesheet.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="stylesheet.xsl" ?>
<test>
1234567890
</test>

Beispieldatei stylesheet.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html><head></head>
 <body style="background-color:#000000; font-family:Algerian; font-size:80px; color:#33FF33">
  <xsl:value-of select="." />
 </body></html>
</xsl:template>

</xsl:stylesheet>

Die XML-Beispieldaten enthalten nur das Wurzelelement mit einer Ziffernfolge als Inhalt. Das Beispiel-Stylesheet ist dementsprechend einfach. Mit xsl:template wird eine Template-Definition zur Übersetzung der XML-Daten in die HTML-Ausgabe definiert. Eingeschlossen werden solche und andere XSL-Definition in das Wurzelelement xsl:stylesheet. Im Beispiel enthält das einleitende Tag dieses Elements die typischen Angaben zur XSLT-Version, zur XSLT-Quelle und zur Quelle des verwendeten HTML-Namensraums (hier: XHTML).

xsl:template (Schablone für Ergebnisbaum definieren)

Dient zum Definieren von Schablonen für Übersetzungen des Ausgangsbaums in den Ergebnisbaum. Dazu wird angegeben, welcher Knoten des Ausgangsbaums in welches Konstrukt des Ergebnisbaums übersetzt werden soll. Bei einer Transformation von eigenen XML-Daten nach HTML kann mit Hilfe einer solchen Template-Definition beispielsweise aus einem Element namens liste eine Aufzählungsliste mit dem ul-Element werden, und untergeordnete Elemente namens listenpunkt lassen sich in entsprechende HTML-Elemente des Typs li transformieren. Das xsl:template-Element ist dadurch wohl das wichtigste und bedeutendste Element von XSLT. Meistens sind Ausgangsbaum (also die Daten, die in einer XML-Datenstruktur vorliegen) und Ergebnisbaum (also die Datenstruktur, in die übersetzt werden soll – z. B. in HTML) so komplex, dass sich nicht alles in einer einzigen Template-Definition erledigen lässt. Stattdessen können Template-Definitionen mit xsl:apply-templates andere Template-Definitionen aufrufen, die z. B. untergeordnete Knoten verarbeiten.

Hat folgende Attribute:

match: (optional) gibt an, für welches Knoten-Set bzw. Pfad nach Seite XPath-Syntax im Ausgangsbaum die Template-Definition gelten soll. Wird dieses Attribut nicht angegeben, muss stattdessen name angegeben werden.
mode: (optional) vergibt einen Namen für den Modus der Template-Definition. Templates mit Modusangabe können mit xsl:apply-templates ausgewählt werden.
name: (optional) vergibt einen Namen für die Template-Definition. Unter diesem Namen kann die Template-Definition mit call-template aufgerufen werden.
priority: (optional) ein numerischer Wert, der Konfliktfälle bei der Reihenfolge des Abarbeitens von Template-Definitionen bewältigen soll. In einigen XSL-Prozessoren ist es bislang so gelöst, dass untergeordnete Templates oder Attributnamen normalerweise den Prioritätswert 0 haben. Untergeordnete Templates oder Attributnamen mit Namensraumangabe plus dem Platzhalter * haben den Prioritätswert -0.25. Ein nicht weiter eingegrenzter Platzhalter * hat den Prioritätswert -0.5. Alle anderen Templates haben einen Prioritätswert von 0.5.

Kann innerhalb von xsl:stylesheet vorkommen. Beispieldatei template.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei template.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei template.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="template.xsl" ?>
<test>
 <titel>Dateiendungen</titel>
 <glossar>
  <eintrag>
   <begriff>bak</begriff>
   <bedeutung>Backup-Datei</bedeutung>
  </eintrag>
  <eintrag>
   <begriff>bmp</begriff>
   <bedeutung>Bitmap-Grafik</bedeutung>
  </eintrag>
 </glossar>
</test>

Beispieldatei template.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="titel">
 <h1><xsl:value-of select="." /></h1>
</xsl:template>

<xsl:template match="glossar/eintrag">
 <p style="font-family:Arial,Helvetica,sans-serif; font-size:16px">
  <xsl:apply-templates />
 </p>
</xsl:template>

<xsl:template match="begriff">
 <b style="color:blue"><xsl:apply-templates />: </b>
</xsl:template>

<xsl:template match="bedeutung">
  <xsl:value-of select="." />
</xsl:template>

</xsl:stylesheet>

Das Beispiel enthält in den XML-Daten eine typische verschachtelte Elementstruktur, in diesem Fall zur Auszeichnung einer glossar-artigen Liste von Dateiendungen und ihrer Bedeutung. Im Beispiel-Stylesheet wird diese XML-Elementstruktur in eine xml-gerechte HTML-Struktur übersetzt. Dies geschieht innerhalb der xsl:template-Definitionen. Solche Template-Definitionen sprechen üblicherweise mit Hilfe des Attributs match ein bestimmtes Element der Ausgangsdaten an. Als Inhalt enthält die Template-Definition dann HTML-Code und andere XSL-Anweisungen, mit deren Hilfe die Übersetzung nach HTML gesteuert wird. Mit der obersten Template-Definition, die match="/" als Angabe hat, wird das Wurzelelement der XML-Daten angesprochen (im Beispiel das Element mit dem Namen test). Um eine ordentliche HTML-Datei zu erzeugen, wird als Inhalt dieser Template-Definition das Grundgerüst der HTML-Datei notiert. Zwischen dem einleitenden und dem abschließenden body-Tag ist die XSL-Anweisung xsl:apply-templates notiert, mit der untergeordnete Template-Definitionen aufgerufen werden, die untergeordnete XML-Elemente verarbeiten. Maßgeblich dafür ist die Baumstruktur der XML-Daten. Im obigen Beispiel hat das Wurzelelement der XML-Daten zwei unmittelbar untergeordnete Elemente, nämlich titel und glossar. Für das titel-Element ist eine eigene Template-Definition notiert (<xsl:template match="titel">). Darin wird mit Hilfe der XSL-Anweisung xsl-value-of der Inhalt des titel-Elements in eine HTML-Überschrift 1. Ordnung übersetzt. Für das glossar-Element existiert im Beispiel keine eigene Template-Definition, erst wieder für dessen untergeordnetes Element eintrag. Damit dieses Template von der Anweisung <xsl:apply-templates />, die innerhalb der Template-Definition des Wurzelelements notiert ist, angesprochen wird, wird es nach Seite XPath-Syntax mit glossar/eintrag adressiert. Jeder Glossareintrag wird im Beispiel in einen CSS-formatierten HTML-Absatz übersetzt. Innerhalb davon werden wiederum mit <xsl:apply-templates /> die Template-Definitionen für untergeordnete XML-Elemente aufgerufen. Im Beispiel sind das die Definitionen für die untergeordneten Elemente begriff und bedeutung.

xsl:text (Zeicheninhalt ausgeben)

Erzeugt statischen Text im Ergebnisbaum.

Hat folgende Attribute:

disable-output-escaping: (optional) bestimmt, wie XML-eigene Zeichen wie < oder > behandelt werden. Mögliche Werte sind yes und no (Voreinstellung). Bei yes werden solche Zeichen nicht in ihre benannten Namen umgewandelt, bei no werden sie umgewandelt.

Kann innerhalb von xsl:template vorkommen. Beispieldatei xsltext.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei xsltext.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei xsltext.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="xsltext.xsl" ?>
<test>
 <behauptung>Die Welt ist ein Dorf</behauptung>
</test>

Beispieldatei xsltext.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates />
 </body>
 </html>
</xsl:template>

<xsl:template match="behauptung">
 <p><xsl:value-of select="." /></p>
<script type="text/javascript">
 <xsl:text>
  &lt;!--
   document.write(&quot;&lt;p&gt;&quot; + document.lastModified + &quot;&lt;/p&gt;&quot;);
  //--&gt;
 </xsl:text>
</script>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten des Beispiels enthalten eine Behauptung. Im Beispiel-Stylesheet wird die Behauptung in einen HTML-Absatz übersetzt. Unterhalb davon ist jedoch noch eine xsl:text-Anweisung zum Erzeugen von weiterem Text notiert. Diese wiederum enthält die HTML-gerechte Notation eines kleinen JavaScripts, das in einem Textabsatz den Zeitpunkt der letzten Änderung der Datei ausgibt. So, wie die Anweisung im Beispiel notiert ist, müssen innerhalb davon die XML-eigenen Zeichen maskiert werden.

xsl:transform (Stylesheet Wurzelelement)

Ist ein Synonym für xsl:stylesheet.

xsl:value-of (Wert ausgeben)

Erzeugt eine gespeicherte Zeichenkette an der aktuellen Position im Ausgabebaum. Bei der gespeicherten Zeichenkette kann es sich z. B. um den Inhalt eines Knotens der XML-Daten handeln, oder um den Inhalt einer zuvor definierten Variablen.

Hat folgende Attribute:

disable-output-escaping: (optional) bestimmt, wie bei der Ausgabe XML-eigene Zeichen wie < oder > behandelt werden. Mögliche Werte sind yes und no (Voreinstellung). Bei yes werden solche Zeichen nicht in ihre benannten Namen umgewandelt, bei no werden sie umgewandelt.
extension-element-prefixes: (optional) gibt Namensräume an, die benötigt werden, um Elemente dieser anderen Namensräume zu erkennen. Erlaubt sind eine oder mehrere Angaben. Mehrere Angaben sind durch Leerzeichen zu trennen.
select: (obligatorisch) Wählt einen Knoten oder eine Variable oder einen Parameter aus, dessen Inhalt verwendet werden soll.

Kann innerhalb von xsl:template vorkommen.

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei value_of.htm)

Anzeigebeispiel (Datei value_of.xml - XML/XSLT-fähiger Browser erforderlich)

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="value_of.xsl" ?>
<test>
 <liste>
   <eintrag>mein Haus</eintrag>
   <eintrag>mein Auto</eintrag>
   <eintrag>mein Boot</eintrag>
 </liste>
</test>

Beispieldatei value_of.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <ul>
  <xsl:apply-templates />
 </ul>
 </body>
 </html>
</xsl:template>

<xsl:template match="liste">
  <xsl:for-each select="eintrag">
   <li><xsl:value-of select="." /></li>
  </xsl:for-each>
</xsl:template>

</xsl:stylesheet>

In den XML-Daten wird eine Liste mit Einträgen definiert. Im Beispiel-Stylesheet wird diese Liste in eine HTML-Aufzählungsliste übersetzt. In der Template-Definition für das Element liste wird mit xsl:for-each für jedes untergeordnete Element eintrag bestimmt, dass dessen jeweiliger Inhalt, der mit <xsl:value-of select="." /> ermittelt wird, in je ein HTML-Listenelement li gesetzt wird. Mit select="." wird der Inhalt des aktuellen Elements ausgewählt. Generell gilt bei der Wertzuweisung an das select-Attribut die Seite XPath-Syntax.

xsl:variable (Variable definieren)

Definiert eine Variable, deren Wert im weiteren Verlauf verwendet werden kann.

Hat folgende Attribute:

name: (obligatorisch) gibt den Namen der Variablen an. Unter diesem Namen kann auf ihren Wert zugegriffen werden.
select: (optional) bestimmt einen Wert für die Variable. Wird dieses Attribut notiert, muss das xsl:variable-Element leer sein. Wird es nicht notiert, erfolgt die Wertzuweisung als Inhalt des Elements zwischen seinem Anfangs- und End-Tag. Mit select kann z. B. ein Element aus den XML-Ausgangsdaten ausgewählt werden. Auch die Vorbelegung mit statischem Text ist möglich, z. B. mit select="'Name:'" (dabei auf die inneren einfachen Anführungszeichen achten!).

Kann innerhalb von xsl:stylesheet vorkommen und kann sowohl außerhalb als auch innerhalb von xsl:template notiert sein. Wenn außerhalb notiert, ist es eine globale Variable, die in allen Template-Definitionen zur Verfügung steht. Wenn innerhalb einer Template-Definition notiert, ist es eine lokale Variable innerhalb des Templates. Beispieldatei variable.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei variable.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei variable.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="variable.xsl" ?>
<test>
 <spruch>
   Das ist ein weites Feld
 </spruch>
 <spruch>
   Morgenstund hat Gold im Mund
 </spruch>
 <spruch>
   Stell dir vor es geht und keiner kriegts hin
 </spruch>
</test>

Beispieldatei variable.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
  <xsl:apply-templates select="test/spruch" />
 </body>
 </html>
</xsl:template>

<xsl:template match="spruch">
 <xsl:variable name="textzuvor">
  <xsl:choose>
   <xsl:when test="position()=1">Erster Eintrag: </xsl:when>
   <xsl:when test="position()=last()">Letzter Eintrag: </xsl:when>
   <xsl:otherwise>Eintrag: </xsl:otherwise>
  </xsl:choose>
 </xsl:variable>
 <p><b><xsl:value-of select="$textzuvor" /></b><br />
 <xsl:value-of select="." /></p>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten des Beispiels enthalten eine Reihe von Sprüchen. Im Beispiel-Stylesheet wird innerhalb der Template-Definition für das Element spruch eine Variable mit dem Namen textzuvor definiert. Es handelt sich um eine lokale Variable, deren Wert als Inhalt zwischen dem Anfangs-Tag <xsl:variable...> und dem Gegenstück </xsl:variable> dynamisch ermittelt wird. Dazu dient eine xsl:choose-Anweisung, bei der mit der Funktion Seite position() ermittelt wird, ob es sich um den ersten Spruch, den letzten oder einen dazwischen handelt. Abhängig davon wird ein unterschiedlicher Text erzeugt: Erster Eintrag, Letzter Eintrag oder einfach nur Eintrag. Dies ist der Wert, der der Variablen textzuvor zugewiesen wird. Da die Template-Definition bei jedem Vorkommen des Elements spruch neu aufgerufen wird, wird auch jedes Mal der Variablenwert neu ermittelt.

xsl:when (Bedingung innerhalb einer Auswahl)

Definiert eine Bedingung bei einer Mehrfachauswahl innerhalb der xsl:choose-Anweisung.

Hat folgende Attribute:

test: (obligatorisch) formuliert die Bedingung.

Kann innerhalb xsl:choose vorkommen.

Beispiel mit Erläuterung siehe xsl:choose, für Bedingungen siehe auch xsl:if.

xsl:with-param (Parameter einen Wert zuweisen)

Weist einem Parameter einen Wert zu, und zwar beim Aufruf einer Template-Definition. In der aufgerufenen Template-Definition wird dann, sofern dieser Parameter dort verfügbar ist, mit dem zugewiesenen Wert gearbeitet.

Hat folgende Attribute:

name: (obligatorisch) gibt den Namen des Parameters an. Unter diesem Namen muss der Parameter innerhalb einer Template-Definition verfügbar sein. Damit der Parameter dort verfügbar ist, muss er mit xsl:param definiert werden.
select: (optional) weist dem Parameter einen Wert zu. Mit select kann z. B. ein Knoten aus den XML-Ausgangsdaten ausgewählt werden. Dann ist dessen Inhalt der zugewiesene Wert. Es kann aber auch ein anderer Ausdruck sein, z. B. ein Rechenausdruck. Auch die Zuweisung von statischem Text ist möglich, z. B. mit select="'Name'" (dabei auf die inneren einfachen Anführungszeichen achten!).

Kann innerhalb von xsl:apply-templates oder xsl:call-template vorkommen. Der zugewiesene Wert ist dann in den aufgerufenen Template-Definitionen verfügbar. Beispieldatei with_param.xml:

Beispiel-Seite Anzeigebeispiel: So sieht's aus (Ergebnisdatei with_param.htm) Beispiel-Seite Anzeigebeispiel: So sieht's aus (Datei with_param.xml – XML/XSLT-fähiger Browser erforderlich)

Anzeigebeispiel

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="with_param.xsl" ?>
<test>
 <start>10</start>
 <ende>20</ende>
</test>

Beispieldatei with_param.xsl:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
 <html>
 <head>
 </head>
 <body>
 <table border="1">
  <xsl:call-template name="Schleife">
    <xsl:with-param name="Zaehler" select="number(/test/start)" />
  </xsl:call-template>
 </table>
 </body>
 </html>
</xsl:template>

<xsl:template name="Schleife">
 <xsl:param name="Zaehler" />
 <xsl:choose>
  <xsl:when test="$Zaehler &lt;= number(/test/ende)">
    <tr>
      <td><xsl:value-of select="$Zaehler" /></td>
      <td><xsl:value-of select="$Zaehler * $Zaehler" /></td>
    </tr>
    <xsl:call-template name="Schleife">
     <xsl:with-param name="Zaehler" select="$Zaehler + 1" />
    </xsl:call-template>
  </xsl:when>
  <xsl:otherwise>
   <xsl:call-template name="Abbruch" />
  </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="Abbruch">
 <xsl:comment>Schleife beendet!</xsl:comment>
</xsl:template>

</xsl:stylesheet>

Die XML-Daten im Beispiel definieren einfach eine kleinere und eine größere Zahl, von denen die erste einen Startwert darstellt und die zweite einen Endwert. Im Beispiel-Stylesheet wird aus diesen Zahlen eine HTML-Tabelle erzeugt, die für alle Zahlen zwischen dem Startwert und dem Endwert in je einer Tabellenzeile die aktuelle Zahl und deren Quadrat ausgibt. Dazu wird innerhalb der Template-Definition für das Wurzelelement mit xsl:call-template eine andere Template-Definition namens Schleife aufgerufen. Innerhalb dieser xsl:call-template-Anweisung ist eine xsl:with-param-Anweisung notiert, die einem Parameter namens Zaehler mit select einen Wert zuweist. In dem Fall ist das der Inhalt des Elements start (Pfad: /test/start). Dabei wird mit Hilfe der Funktion number() sichergestellt, dass der Inhalt des Elements als Zahl interpretiert wird. In der aufgerufenen Template-Definition Schleife wird mit <xsl:param name="Zaehler" /> der Parameter namens Zaehler definiert. Nur so ist es der Template-Definition möglich, mit dem Wert dieses Parameters, der ihr beim Aufruf übergeben wurde, zu arbeiten. Eine Alternative wäre es, wenn Zaehler global definiert wäre. Mit <xsl:when test="$Zaehler <= number(/test/ende)"> wird abgefragt, ob der Wert von Zaehler kleiner oder gleich dem Wert ist, der im Element ende gespeichert ist. Ist das der Fall, wird eine Tabellenzeile erzeugt, die den Wert und sein Quadrat ausgibt. Außerdem ruft sich das Template Schleife selbst wieder auf und übergibt sich dabei wiederum den Parameter Zaehler. Dieser wird um 1 erhöht, sodass die Template-Definition beim nächsten Aufruf die nächsthöhere Zahl abfragt. Ist der Wert des Elements ende überschritten, wird eine Template-Definition namens Abbruch aufgerufen, die lediglich einen abschließenden Kommentar in den auszugebenden HTML-Code setzt.

Referenz

XML/XSL/XSLT/Sprachelemente

Inhaltsverzeichnis

xsl:apply-imports (importierte Stylesheets anwenden)

xsl:apply-templates (untergeordnete Schablonen anwenden)

xsl:attribute (Attribut im Ergebnisbaum erzeugen)

Attributwert-Templates (XPath-Ausdrücke inline verwenden)

xsl:attribute-set (mehrere Attribute im Ergebnisbaum erzeugen)

xsl:call-template (Schablone aufrufen)

xsl:choose (Auswahl treffen)

xsl:comment (Kommentar setzen)

xsl:copy (Element in Ergebnisbaum kopieren)

xsl:copy-of (Beliebige ermittelte Daten in Ergebnisbaum kopieren)

xsl:decimal-format (Dezimalformat)

xsl:element (Element erzeugen)

xsl:fallback (alternative Ausführungsanweisung)

xsl:for-each (für jedes Element aus einer Menge wiederholen)

xsl:if (Wenn-Bedingung)

xsl:include (Stylesheets inkludieren)

xsl:import (Stylesheets importieren)

xsl:key (Schlüssel für Auswahl von Elementen)

xsl:message (Meldung beim Transformieren ausgeben)

xsl:namespace-alias (Stylesheet in anderes Stylesheet transformieren)

xsl:number (fortlaufende Nummerierung)

xsl:otherwise (Andernfalls-Anweisung)

xsl:output (Erzeugen des Ergebnisbaums kontrollieren)

xsl:param (Parameter definieren)

xsl:preserve-space (Leerraumzeichen beibehalten)

xsl:processing-instruction (Stylesheet-Code generieren)

xsl:sort (Elemente nach Inhalt sortieren)

xsl:strip-space (Behandlung von Leerraumzeichen steuern)

xsl:stylesheet (Stylesheet Wurzelelement)

xsl:template (Schablone für Ergebnisbaum definieren)

xsl:text (Zeicheninhalt ausgeben)

xsl:transform (Stylesheet Wurzelelement)

xsl:value-of (Wert ausgeben)

xsl:variable (Variable definieren)

xsl:when (Bedingung innerhalb einer Auswahl)

xsl:with-param (Parameter einen Wert zuweisen)

Referenz

Navigationsmenü

Suche