<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
 <!-- Inhalt des Dokumentes -->
</xsl:stylesheet>

Außer des Namespaces muss auch die verwendete Version angegeben werden (derzeit 1.0). Anstelle des xsl:stylesheet-Elements kann auch das Synonym xsl:transform verwendet werden. Es verhält sich ebenso wie das eigentliche XSLT-Element, bietet allerdings einen begreifbareren Namen (eben Transformierung und nicht Formatierung).

Als Unterelemente sind folgende erlaubt, man bezeichnet sie als Top-Level Elemente: xsl:import, xsl:include, xsl:strip-space, xsl:preserve-space, xsl:output, xsl:key, xsl:decimal-format, xsl:namespace-alias, xsl:attribute-set, xsl:variable, xsl:param und xsl:template. Die meisten dieser Elemente werden im folgenden noch erklärt werden.

Mit Templates arbeiten  nach oben

Innerhalb von XSLT werden Templates verwendet. Ein Template ist sozusagen eine Vorlage für die Transformation von bestimmten Knoten. Diese Knoten können z.B. Elemente, Attribute oder Text sein. Vorlagen werden durch das xsl:template-Element erstellt und beschrieben. Es besitzt unter Anderem die Attribute match und name. Letzteres definiert einen eindeutigen Namen für das Template. Dieser kann später weiter verwendet werden. Mit dem match-Attribut wird exakt spezifiziert, auf welche Knoten der Quell-Datei diese Vorlage angewandt werden soll. Die Werte dieses Attributes werden als Patter bezeichnet. Folgende Patter sind hier unter anderem möglich:

WertBeschreibung
ElementnameWird ein Elementname oder eine durch | verbundene Liste von Elementnamen definiert, gilt die Vorlage für alle benannten Elemente innerhalb der Liste.
/Das root-Element wird verwendet.
Elementname1/Elementname2Wird auf alle Elementname2 angewandt, die Elementname1 als Eltern-Element haben.
Elementname1//Elementname2Wird auf alle Elementname2 angewandt, die Elementname1 als Vorfahren-Element (z.B. Eltern-Element oder Eltern-Element vom Eltern-Element usw.) haben.
id(Name)Wird auf alle Elemente angwandt die die ID Name haben.
key(Name,Wert)Wird auf alle Elemente angewandt, die durch einen Schlüssel (xsl:key) mit dem jeweiligen Namen definiert werden und den Wert haben.
text()Wird auf alle Text-Knoten angewandt.
processing-instruction()Wird auf alle PI's angewandt.
node()Wird auf alle Knoten angewandt, die keine Attribute oder das Root-Element sind.
Elementname[n]Wird auf alle Elemente Elementname angewandt, wenn sie das n-te Element innerhalb des Elternelements sind.
*Alle Knoten werden verwendet.
position() = xAlle Elemente mit der Positionsnummer x werden verwendet. Auch sind Rechenformeln denkbar: position() mod 4 = 0 (jeder 4te Knoten)
@NameAlle Attribut-Knoten mit dem Namen Name.
Elementname[@Attributname="Wert"]//Alle Elemente mit dem Attributwert Wert des Attributes Attributname.

Dies ist allerdings nur eine kleine Auswahl der wichtigsten Patter. XSLT definiert hier noch unzählige weitere und erlaubt darüber hinaus auch die Kombination mit/und XPatch Ausdrücke/n.

Gelangt der XSLT-Parser zu einem Knoten für den ein Template definiert wurde, ersetzt er diesen Knoten durch das Template. Innerhalb des Templates können dazu weitere XSLT-Angaben oder auch Text oder Markup folgen. Diese werden dann als weitere Knoten angesehen und ebenfalls abgeschritten. Beispiel XML-Quelle:

<?xml version="1.0"?>
<?xml-stylesheet href="trans1.xsl" type="text/xsl"?>
<!DOCTYPE A [
<!ELEMENT A (#PCDATA | B)*>
<!ELEMENT B (#PCDATA | C)*>
<!ELEMENT C EMPTY>
]>
<A>
 <B>
  <C />
 </B>
</A>

XSLT -Stylesheet:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="A">
 <html>
 <body>
 &lt;Element<b>A</b>&gt;
 <xsl:apply-templates />
 &lt;/Element<b>A</b>&gt;
 </body>
 </html>
</xsl:template>
<xsl:template match="B">
 &lt;Element<b>B</b>&gt;
 <xsl:apply-templates />
 &lt;/Element<b>B</b>&gt;
</xsl:template>
<xsl:template match="C">
 &lt;Element<b>C</b> /&gt;
</xsl:template>
</xsl:stylesheet>

Werden die obigen Daten auf das darunterstehende Stylesheet angewandt, so erhält man letztlich folgendes Bild:

Resultat der Transformierung
Darstellung: Resultat der Transformierung

Templates in Templates  nach oben

Durch die Verschachtelung von XML-Elementen, wie im obigen Beispiel zu sehen, wird es nötig, innerhalb eines Templates ein anderes verwenden zu können. Dies erfolgt über das xsl:apply-templates-Element. Es besagt, dass an dieser Stelle andere Templates eingebunden werden können (sofern die entsprechenden Knoten existieren). Wird das Element als leeres Element notiert (siehe Beispiel oben) heißt dies, dass hier alle Vorlagen erscheinen können. Darüber hinaus kann der Vorlagenbereich auch eingeschränkt werden. Dies erfolgt über das select-Attribut, welches als Wert wiederum einen Patter erhalten kann (siehe Patter). Auch können mehrere xsl:apply-templates-Elemente innerhalb eines xsl:template-Elements enthalten sein. Beispiel (es wird die obige Quelleverwendet):

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="A">
 <html>
 <body>
 <p>Der Inhalt von B wird ausgelassen,
 stattdessen folgt der Inhalt von C:</p>
 <p>"<xsl:apply-templates select="C" />"</p>
 </body>
 </html>
</xsl:template>
<xsl:template match="B">
 Anfang B
 <xsl:apply-templates/>
 Ende B
</xsl:template>
<xsl:template match="C">
 Dies ist der Inhalt von C
</xsl:template>
</xsl:stylesheet>

... erzeugt das folgende Resultat:

Resultat der Transformierung
Darstellung: Resultat der Transformierung

Templates einbinden  nach oben

Um Templates auch an stellen verwenden zu können, an denen es eigentlich nicht auftreten sollte (da z.B. keine entsprechenden Knoten vorhanden sind), benutzt man das xsl:call-template-Element. Es erhält als Wert des name-Attributes den Namen eines Templates, das an dieser Stelle eingebunden werden soll. Beispiel (es wird die obige Quelle verwendet) :

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="A">
 <html>
 <body>
 <p>Inhalt von C:</p>
 <p><b><xsl:apply-templates select="C" /></b></p>
 </body>
 </html>
</xsl:template>
<xsl:template name="tempB" match="B">
 Anfang B
 <xsl:apply-templates />
 Ende B
</xsl:template>
<xsl:template match="C">
 Dies ist der Inhalt von C<br />
 <xsl:call-template name="tempB" />
</xsl:template>
</xsl:stylesheet>

... erzeugt:

Resultat der Transformierung
Darstellung: Resultat der Transformierung

Mehrere Stylesheets verwenden  nach oben

Es gibt zwei Wege um in einem XSLT-Dokument die Angaben eines anderen verwenden zu können. Im ersten Fall benutzt man dazu das xsl:include-Element. Als Wert des href-Attributes erhält dies die URL der zu verwendenden Datei. Diese wird eingelesen und die enthaltenen Angaben werden in das aktuelle Dokument eingebunden (an der Stelle an der der Aufruf stattfand). Im zweiten Fall benutzt man das xsl:import-Element. Auch hier wird das href-Attribut mit der jeweiligenURLdefiniert. Der Unterschied zu xsl:include besteht darin, dass die Regeln des improtierten Stylesheets Vorrang vor denen aus dem eigentlichen Dokument haben. Beispiel:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:import href="trans1.xsl">
 <!-- ... -->
 <xsl:include href="inc1.xsl">
 <!-- ... -->
</xsl:stylesheet>

Bitte beachten Sie, dass beide Elemente nur als Top-Level Element verwendbar sind. Außerdem sollten die xsl:import-Elemente vor allen anderen Elementen definiert werden - xsl:include-Elemente können danach überall auf root-Ebene vertreten sein.

Elemente erzeugen  nach oben

XSLT bietet zum Erzeugen der Resultate vorgefertigte Lösungen (/Elemente). Diese können angwandt werden um zum Einen einen sauberen Syntax des Resultat-Dokuments zu erhalten und um Zum Zweiten Knoten erzeugen zu können, die innerhalb der Quelle schonmals verwendet wurden. Elemente werden mit xsl:element erzeugt. Es besitzt die Attribute name (Name des Element), namespace (Namensraum des Element) sowie use-attribute-sets (Name einer zu verwendenden Attributliste). Der Name sollte unbedingt definiert werden - der Namespace und die Attributliste stehen frei. Innerhalb des xsl:element-Elements können beliebige Informationen folgen (Text, Markup, Kommentare ...). Beispiel:

<xsl:element name="MeinElement" >
 Das ist mein Element.
</xsl:element>

... erzeugt:

<MeinElement> Das ist mein Element. </MeinElement>

Attribute erzeugen  nach oben

Ebenso wie Elemente erzeugt werden können, ist es natürlich auch möglich, diesen Attribute zuzuweisen. Dazu verwendet man das xsl:attribute-Element. Es erhält als Wert des name-Attributes den zu verwendenden Namen sowie ggf. einen Namespace (namespace-Attribut). Innerhalb des Elements wird der Wert des erzeugten Attributes notiert. Beispiel:

<xsl:element name="MeinElement" >
 <xsl:attribute name="MeinAttribut">MeinWert</xsl:attribute>
 <p>
  <xsl:attribute name="align">right</xsl:attribute>
   Das ist mein Element.
 </p>
</xsl:element>

... erzeugt:

<MeinElement MeinAttribut="MeinWert">
 <p align="right">
   Das ist mein Element.
 </p>
</MeinElement>

Bitte beachten Sie, das das Element nur innerhalb eines xsl:element-, xsl:attribute-set- oder definierten Elements verwendet werden kann. Außerdem sollten Sie darauf achten, dass die Attribut-Definition direkt nach der Element-Definition stehen, d.h. dass kein Text dazwischen sein sollte.

Attributlisten  nach oben

Attributlisten sind - wie der Name schon sagt - Listen von Attributen. Sie dienen dazu häufig verwendete Attribute schneller verwenden zu können, indem man sie einem Element eben nur über das use-attribute-sets-Attribut zuweisen braucht und nicht jedes Mal neu definieren muss. Attribut-Listen werden durch das xsl:attribute-set-Element definiert und beinhalten ausschließlich Attribute (xsl:attribute). Außerdem müssen sie durch das name-Attribut mit einem Namen versehen werden der dann von Elementen verwendet werden kann. Beispiel Quelle:

<?xml version="1.0"?>
<?xml-stylesheet href="trans.xsl" type="text/xsl"?>
<!DOCTYPE A [
<!ELEMENT A ( B )*>
<!ELEMENT B EMPTY>
]>
<A>
 <B />
</A>

XSLT -StyleSheet:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:attribute-set name="Liste1">
 <xsl:attribute name="align">right</xsl:attribute>
 <xsl:attribute name="style">color:red;</xsl:attribute>
</xsl:attribute-set>
<xsl:attribute-set name="Liste2" use-attribute-sets="Liste1">
 <xsl:attribute name="src">meinbild.gif</xsl:attribute>
</xsl:attribute-set>
<xsl:template match="A">
 <html>
 <body>
 <xsl:element name="h3" use-attribute-sets="Liste1">
 Attributlisten
 </xsl:element>
 <hr />
 <xsl:apply-templates/>
 </body>
 </html>
</xsl:template>
<xsl:template match="B">
 <xsl:element name="img" use-attribute-sets="Liste2" />
</xsl:template>
</xsl:stylesheet>

... erzeugt:

<html>
 <body>
  <h3 align="right" style="color:red;">
   Attributlisten
  </h3>
  <hr>
  <img align="right" style="color:red;" src="meinbild.gif">
 </body>
</html>

Resultat der Transformierung
Darstellung: Resultat der Transformierung

Des Weiteren unterstützt das Element die Verwendung weiterer Attribut-Listen die als eine durch Leerzeichen getrennte Liste als Wert des use-attribute-sets-Attributes definiert werden können (siehe Beispiel oben). Bitte beachten Sie, dass es sich dabei um ein Top-Level Element handelt.

Sonstiges erzeugen  nach oben

Neben Elementen und dazugehörigen Attributen können auch Texte, Processing-Instructions oder Kommentare erzeugt werden. Da diese sich in etwa gleich der Erzeugung von Elementen verhalten, soll das folgende Beispiel genügen um die Verwendung der einzelnen Elemente zu verdeutlichen:

<xsl:text> Inhalt </xsl:text>
<xsl:processing-instruction name="xml-stylesheet">
 href="test1.xsl" type="text/xsl"
</xsl:processing-instruction>
<xsl:comment>
 Dies ist ein Kommentar.
</xsl:comment>

... erzeugt:

Inhalt 
<?xml-stylesheet href="test1.xsl" type="text/xsl">
<!--
 Dies ist ein Kommentar.
-->

Computer generierten Text erzeugen  nach oben

Neben der Möglichkeit mit xsl:text ziemlich statisch Text erzeugen zu können, bietet XSLT die Voraussetzungen Text durch den Parser erstellen zu lassen. Dazu wird das xsl:value-of-Element im Zusammenhang mit dessen select-Attribut verwendet. Tritt dieses auf, wird der Wert des durch select beschriebenen Knotens an dieser Stelle eingefügt. Beispiel:

<xsl:template match="Person">
 <xsl:value-of select="@Anrede" /> heisst:
 <xsl:value-of select="@Vorname" />
 <xsl:text><b></xsl:text>
 <xsl:value-of select="@Nachname" />
 <xsl:text></b></xsl:text>.
</xsl:template>

... erzeugt z.B.:

Er heisst: Max <b>Mustermann</b>.

Bitte beachten Sie, dass innerhalb von Elementen (egal ob XSLT oder Markup) statt dieser Schreibweise auch einfach geschweifte Klammern ({ und }) verwendet werden können. Sie stehen als Synonym für das xsl:value-of-Element. Innerhalb der Klammern notieren Sie dann den Wert, den Sie üblicherweise als select-Wert notiert hätten.