## XSLT-Elemente

Hinweise zu den XSLT-Elementen
xsl:apply-imports (importierte Stylesheets anwenden)
xsl:apply-templates (untergeordnete Schablonen anwenden)
xsl:attribute (Attribut im Erbebnisbaum erzeugen)
xsl:attribute-set (Mehrere Attribute im Erbebnisbaum 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-Bedinungung)
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)

## Hinweise zu den XSLT-Elementen

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 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.

Beachten Sie zum Thema Internet Explorer die Hinweise zu den Beispielen.

## 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.

### Beispieldatei apply_imports.xml:

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

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

### Beispieldatei apply_imports1.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Beispieldatei apply_imports2.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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. einen 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.

### Beispieldatei apply_templates.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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>

### Beispieldatei apply_templates.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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:14pt">
     <xsl:apply-templates />
     </p>
    </xsl:template>

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

    </xsl:stylesheet>

### Erläuterung:

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 Erbebnisbaum erzeugen)

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

Hat folgende Attribute:

`name=` | (obligatorisch) Gibt den Namen des Attributs an, z.B. `align`.
`namespace=` | (optional) 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 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.

## xsl:attribute-set (mehrere Attribute im Erbebnisbaum 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 Beispiel-Ausschnitts 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 einmal die Definition einer sichtbaren Tabelle und einmal die einer unsichtbaren Tabelle 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?xml-stylesheet type="text/xsl" href="call_template.xsl" ?>
    <test>
    <kontakt mail="ludo@ruski.net">Stanislaw Ludowiczy</kontakt>
    </test>

### Beispieldatei call_template.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>, Mailadresse: </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>

### Erläuterung:

Das XML-Beispiel enthält Kontaktdaten, wobei im Element `kontakt` als Inhalt der Name notiert wird, und das Element als Attribut die zugehörige Mailadresse 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@ruski.net">Stanislaw Ludowiczy</kontakt>` die Ausgabe `<div>Stanislaw Ludowiczy, Mailadresse: ludo@ruski.net</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.

### Beispieldatei choose.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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:

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

### Erläuterung:

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, wo 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.

### Beispieldatei copy.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 macht Sinn, 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, wo 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.

### Beispieldatei copy_of.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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.

### Beispieldatei decimal_format.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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` 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) Name des zu generierenden Elements, z.B. `table` für das gleichnamige HTML-Element
`namespace=` | (optional) 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.

### Beispieldatei element.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 Element liefert die Funktion position(). Der Ausdruck `mod 2 = 0` fragt, ob die Modulodivision 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="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

Im Beispiel-Stylesheet wird mit der Anweisung xsl:processing-instruction ein CSS-Stylesheet 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 CSS-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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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.

### Beispieldatei if.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 mehr 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 &gt;= 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 der XML-basierten Anweisungen 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-Operatoren beschrieben.

## 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, wo der Schlüssel im Elementbaum ansetzen soll.

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

### Beispieldatei key.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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: So sieht's aus (Datei message.xml - XML/XSLT-fähiger Browser meldet Message-Fehler)

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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 > 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>

### Erläuterung:

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.

### Beispieldatei namespace_alias.xml:

Anzeigebeispiel: So sieht's aus (Ergebnisdatei namespace_out.htm - über den Umweg von von output.xsl erzeugt)
Anzeigebeispiel: So sieht's aus (Datei namespace_alias.xml)

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

### Beispieldatei namespace_alias.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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 `lt;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) 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 beendet werden soll.
`grouping-separator=` | (optional) Trennzeichen für Zifferngruppen bei hohen Zahlen, z.B. Tausender-Trennzeichen. In der deutschen Schreibweise von Zahlen üblicherweise ein Punkt (`.`).
`grouping-size=` | (optional) Anzahl der Ziffern, bei der ein Trennzeichen gesetzt wird. Bei Tausender-Trennzeichen wäre das der Wert `3`.
`lang=` | (optional) gibt das Land (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) 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 Elementbaums 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 Elementbaums 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 Elementbaum 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 Elementbaums 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 Elementbaum 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.

### Beispieldatei number.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?xml-stylesheet type="text/xsl" href="number.xsl" ?>
    <test>
    <link>http://selfaktuell.teamone.de/</link>
    <link>http://alpentouren.teamone.de/</link>
    <link>http://www.selfhtml.com.fr/</link>
    </test>

### Beispieldatei number.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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 durchgefuehrt 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 welchem Zeichensatz der Ergebnisbaum kodiert wird. Sinnvoll ist eine Angabe nach RFC2278.
`indent=` | (optional) kann die Werte `yes` oder `no` (Voreinstellung) 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.
`media-type=` | (optional) gibt den Mime-Type 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 ja oder `no` für nein.
`standalone=` | (optional) bestimmt bei `omit-xml-declaration="yes"`, dass sich die DTD-Deklarationen in der aktuellen Datei befinden (vergleiche Zusätzliche Angaben zum Zeichensatz und zum DTD-Bezug)
`version=` | (optional) bestimmt bei bestimmt bei `omit-xml-declaration="yes"` die XML-Versionsangabe.

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

### Beispieldatei output.xml:

Anzeigebeispiel: So sieht's aus (Ergebnisdatei output_en.xml - XML-fähiger Browser erforderlich, der die Datenstruktur anzeigt)

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <xsl:output method="xml" indent="yes" encoding="ISO-8859-1" 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>

### Erläuterung:

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 Elementbaum-Aufbau gebracht werden, deren Elementnamen jedoch englische 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="ISO-8859-1"` der Zeichensatz bestimmt. 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ücklauf-Zeichen) or `#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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?xml-stylesheet type="text/xsl" href="preserve_space.xsl" ?>
    <test>

    <kontakt>Hannes Breuer, breuer@myworld.net</kontakt>

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

    </test>

### Beispieldatei preserve_space.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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 Verarbeitungsanweisung.

Hat folgende Attribute:

`name=` | (obligatorisch) bestimmt den Namen der Verarbeitungsanweisung.

Kann innerhalb von xsl:template vorkommen.

### Beispieldatei processing_instruction.xml:

Anzeigebeispiel: So sieht's aus (Ergebnisdatei processing.xml - XML/CSS-fähiger Browser erforderlich)

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <xsl:output method="xml" omit-xml-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; }

### Erläuterung:

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 CSS-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" ?>`
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) 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).
`data-type=` | (optional) 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) gibt das Land (nach 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"`).
`order=` | (optional) 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).
`select=` | (optional) gibt an, was sortiert werden soll. Wird das Attribut weggelassen, ist der Inhalt des betroffenen Elements dasjenige, was sortiert wird.

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

### Beispieldatei sort.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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ücklauf-Zeichen) or `#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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?xml-stylesheet type="text/xsl" href="strip_space.xsl" ?>
    <test>

    <kontakt>Hannes Breuer, breuer@myworld.net </kontakt>

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

    </test>

### Beispieldatei strip_space.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?xml-stylesheet type="text/xsl" href="stylesheet.xsl" ?>
    <test>
    1234567890
    </test>

### Beispieldatei stylesheet.xsl:

    <?xml version="1.0" encoding="iso-8859-1"?>
    <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>

### Erläuterung:

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 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 xsl: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 Atrributnamen 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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:12pt">
      <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>

### Erläuterung:

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 Baumtruktur 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 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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.

### Beispieldatei value_of.xml:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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="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>

### Erläuterung:

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 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 jedesmal 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. eine 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:

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

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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="iso-8859-1"?>
    <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>

### Erläuterung:

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 moeglich, 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.

| XPath-Syntax
| Beispiele für XSLT

© 2001 selfhtml@teamone.de