E-Book Startseite Karteikarten-Programm
0

Das Wurzelelement

Alle XSLT-Elemente beginnen meistens mit xsl. Dies ist der Namensraum für alle XSLT-Elemente, welcher aber selbst festgelegt werden kann. Das Stylesheet-Wurzelelement heißt stylesheet. Alle XSL-Elemente müssen diesem untergeordnet sein. Es gibt ein paar Attribute, die in diesem Wurzelelement eingesetzt werden können bzw. müssen. Zwingend notwendig ist die Namensraumangabe (xmlns:xsl="http://www.w3.org/1999/XSL/Transform") und die Versionsangabe (version="1.0"). Es gibt jedoch noch 3 weitere Attribute. Diese sind jedoch alle optional. Mit id kann eine eindeutige Bezeichnung vergeben werden. Mit den Attributen extension-element-prefixes und exclude-result-prefixes können Angaben zu Namensräumen durchgeführt werden, die innerhalb des Stylesheet-Wurzelelements benötigt werden. Mehrere Angaben werden dabei mit Leerzeichen getrennt. Der Unterschied zwischen den 2 Attributen ist, dass bei dem 2. Attribut bei der Erzeugung des Ergebnisbaums die Namensräume nicht übernommen werden. Eine Alternative zu xsl:stylesheet ist xsl:transform Einen Unterschied gibt es bei den 2 Elementen nicht. Hier ein einfaches Beispiel (1.Datei XML - 2. Datei XSL). Bitte beachten Sie das ein Fehler erscheint, da es ein leeres Dokument ist.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslwurzel.xsl" type="text/xsl"?>
 
<tag>
  Inhalt
</tag>
<?xml version="1.0" encoding="ISO-8859-1"?>
 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
</xsl:stylesheet>

Templates und Schablonen

Ein Hauptbestandteil bei den Transformationen bilden die sogenannten Templates, zu Deutsch Schablonen. Mit dem Element template können Schablonen definiert werden, mit denen später gute Übersetzungen vorgenommen werden. Mit dem Attribut match wird die Pfadangabe mit XPath durchgeführt. Eine Alternative zu diesem Attribut ist name. Dabei vergibt man einen Namen. Aufgerufen wird dieses dann mit dem Element call-template. Wenn match verwendet wird, wird als Aufruf nicht call-template sondern apply-templates verwendet. Das Element apply-templates ist ein einteiliges Element und muss daher als kennungsleer gekennzeichnet werden. Das Element template hat des Weiteren noch zwei weitere optionale Attribute. Alternativ zu match und name, aber auch in Kombination mit match, gibt es noch mode. Mit dem mode-Attribut kann ein Modus-Name vergeben werden und dieser später mit apply-templates aufgerufen werden. Das 4. optionale Attribut ist priority. Damit kann eine Priorität festgelegt werden. Diese Priorität gilt bei der Abarbeitung der verschiedenen Befehle. apply-templates ist ein sehr wichtiges Element, da damit die Schablonen angewendet werden können. Das Element bietet zwei optionale Attribute: select wird verwendet um ein Template auszuwählen. Wenn das Attribut nicht verwendet werden alle Templates aufgerufen. Das 2. Attribut ist mode, welches verwendet wird um mit dem angegebenen Modus-Namen im template-Element zu kommunizieren. Wenn dieses Attribut verwendet wird, muss auch das select-Attribut verwendet werden. Das 3. Element im Gebiet der Schablonen ist call-template, mit dem die Templates die mit template festgelegt worden sind aufgerufen werden können. Das Element benötigt das Attribut name. Dieses muss mit dem name-Attribut im template-Element übereinstimmen. Oft wird dieses Element innerhalb eines Weiteren Templates verwendet. Die Beispiel-XML-Datei ist ein einfacher Aufbau einer E-Mail-Verteiler-Liste von einer Firma. In der XSL-Datei werden mehrere apply-templates-Elemente verwendet. Diese Datei soll erklären wie die Anwendung solcher Elemente funktioniert. Denn dieses Anwendungselement wird an vielen verschiedenen Orten verwendet. Als erstes wird es im Haupt-Template (match="/"). Damit wird angegeben, dass entweder Inhalt ausgegeben werden soll oder untergeordnete Templates angewendet werden sollen. In diesem Fall gibt es untergeordnete Templates, daher werden diese untergeordnet. Das ganze Dokument wird nun so abgearbeitet und die Struktur eingegrenzt bis der "Text" kommt. Dieser kann dann mit dem apply-templates-Element ausgegeben werden. Wie die Funktionsweise von call-template funktioniert eignet sich jetzt noch nicht zu erklären wird aber innerhalb dieses Kapitels noch behandelt. Hier nun das Beispiel zu template und apply-templates:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xsltemplate.xsl" type="text/xsl"?>
 
<dokument>
  <seitentitel>E-Mail-Verteiler von "Firma XY"</seitentitel>
  <main>
    <person>
      <name>Lisa</name>
      <email>lisa@firmaxy.com</email>
    </person>
    <person>
      <name>Peter</name>
      <email>peter@firmaxy.com</email>
    </person>
    <person>
      <name>David</name>
      <email>david@firmaxy.com</email>
    </person>
  </main>
</dokument>
<?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="seitentitel">
  <h3><xsl:apply-templates /></h3>
</xsl:template>
 
<xsl:template match="main/person">
  <p><xsl:apply-templates /></p>
</xsl:template>
 
<xsl:template match="name">
  <b><xsl:apply-templates />: </b>
</xsl:template>
 
<xsl:template match="email">
  <xsl:apply-templates />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Stylesheet inkludieren

Stylesheets sind kombinierbar: Dazu nutzt man das include-Element. Dabei wird ein weiteres Stylesheet in das Hauptstylesheet importiert. Innerhalb der XML-Datei ändert sich nichts. Dort wird weiterhin nur die Adresse der Hauptstylesheet angegeben. In diesem Stylesheet wird dann mit include ein weiteres Stylesheet importiert. Dies kann selbstverständlich in dieser Reihe weiter gehen, aber auch mehrere von diesen Elementen im Hauptstylesheet oder auch in anderen verwendet werden. Das einzigste Attribut, dass es in diesem Element gibt ist ein Pflichtattribut namens href. Dort wird der Link zum Stylesheet angegeben. Diese Art eignet sich vor allem bei sehr großen Projekten. Das Element darf nicht innerhalb von anderen Elementen stehen, muss jedoch innerhalb von stylesheet vorkommen. Als Anwendungsbeispiel nehmen wir uns das gleiche Beispiel von vorher. Jedoch werden die letzten 2 Templates im ersten Dokument abgeschnitten und im zweiten Dokument eingesetzt. Das Hauptstylesheet erhält nun nur noch den Link zur 2. Datei. Der Quellcode dafür sieht so aus (1. XML-Dokument - 2. XSL-Dokument 1 - 3. XSL-Dokument 2):

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslinclude.xsl" type="text/xsl"?>
 
<dokument>
  <seitentitel>E-Mail-Verteiler von "Firma XY"</seitentitel>
  <main>
    <person>
      <name>Lisa</name>
      <email>lisa@firmaxy.com</email>
    </person>
    <person>
      <name>Peter</name>
      <email>peter@firmaxy.com</email>
    </person>
    <person>
      <name>David</name>
      <email>david@firmaxy.com</email>
    </person>
  </main>
</dokument>
<?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="seitentitel">
  <h3><xsl:apply-templates /></h3>
</xsl:template>
 
<xsl:template match="main/person">
  <p><xsl:apply-templates /></p>
</xsl:template>
 
<xsl:include href="xslinclude2.xsl" />
</xsl:stylesheet>
<?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="name">
  <b><xsl:apply-templates />: </b>
</xsl:template>
 
<xsl:template match="email">
  <xsl:apply-templates />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Stylesheet importieren und anwenden

Zu dem bisher bekannten "include"-Mechanismus gibt es noch den "import"-Mechanismus. Der Unterschied liegt darin, dass xsl:include 2 oder mehrere Stylesheets kombiniert. xsl:import importiert ein weiteres Stylesheet an einer beliebigen Stelle und wird nur dort dann angewendet. Die Anwendung bzw. der Code von import ist gleich wie bei include. Denn auch hier wird href als Attribut verwendet, um die Quelle der Datei anzugeben. Dieses Element darf nicht innerhalb von einem Template-Element vorkommen und muss daher genauso wie das include-Element plaziert werden. Innerhalb eines beliebigen Templates kann dann mit apply-imports die angegebene Datei an dieser Stelle importiert werden. Als Beispiel haben wir nun noch Mals das gleiche Beispiel wie bei den 2 vorherigen Unterpunkten. Jedoch wird die Datenverteilung wieder anders sein. Alle Templates (außer das Haupt- / Wurzel-Template) befinden sich in der 2. Datei. In der ersten Datei wird im Haupt-Template angegeben, dass dort der Import angewendet werden soll. Des Weiteren wird hinter dem Template der Pfad angegeben. In der 2. Datei befinden sich nun alle weitere Templates. Die Praxis sieht so aus:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xsltemplate.xsl" type="text/xsl"?>
 
<dokument>
  <seitentitel>E-Mail-Verteiler von "Firma XY"</seitentitel>
  <main>
    <person>
      <name>Lisa</name>
      <email>lisa@firmaxy.com</email>
    </person>
    <person>
      <name>Peter</name>
      <email>peter@firmaxy.com</email>
    </person>
    <person>
      <name>David</name>
      <email>david@firmaxy.com</email>
    </person>
  </main>
</dokument>
<?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-imports />
    </body>
  </html>
</xsl:template>
 
<xsl:import href="xslimport2.xsl"/>
</xsl:stylesheet>
<?xml version="1.0" encoding="ISO-8859-1"?>
 
<xsl:template match="seitentitel">
  <h3><xsl:apply-templates /></h3>
</xsl:template>
 
<xsl:template match="main/person">
  <p><xsl:apply-templates /></p>
</xsl:template>
 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="name">
  <b><xsl:apply-templates />: </b>
</xsl:template>
 
<xsl:template match="email">
  <xsl:apply-templates />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Transformieren eines Stylesheets in ein anderes Stylesheet

Mit dem Element namespace-alias kann man ein Stylesheet in ein anderes Transformieren. Dazu werden 2 Dinge benötigt. Alle Elemente die Transformiert werden sollen, und normalerweise mit dem Namensraum xsl markiert werden, erhalten einen eigenen Namensraum. Dieser kann frei gewählt werden (Namensregeln beachten!). In dem XSL-Wurzelelement muss dazu ein eigene4 Namensraum vergeben werden, jedoch nicht so wie Sie es bereits kennen. Denn es wird nicht zum W3C verlinkt, sondern der Pfad der zu transformierenden Datei angegeben. Nun kommt noch das eigentliche namespace-alias-Element zur Verwendung. Dort gibt es 2 Attribute: stylesheet-prefix und result-prefix. stylesheet-prefix gibt den Namensraum an. Dies muss selbstverständlich der gleiche sein, der schon oben zusätzlich im Wurzel-Element notiert wurde. In result-prefix kann notiert werden wie der Namensraum in der Ausgangsdatei heißen soll.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslnamespacealias.xsl" type="text/xsl"?>
 
<dokument>
  <titel>Titel der Output-Datei</titel>
</dokument>
<?xml version="1.0" encoding="ISO-8859-1"?>
 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:transform="xslnamespacealias2.xsl">
 
<xsl:namespace-alias stylesheet-prefix="transform" result-prefix="xsl" />
 
<xsl:template match="/">
  <transform:stylesheet version="1.0">
    <transform:template match="titel">
      <html><head></head><body>
        <h1><transform:apply-templates /></h1>
      </body></html>
    </transform:template>
  </transform:stylesheet>
</xsl:template>
 
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



for-each-Schleife

Das 1. notwendig Element, für eine Schleife heißt value-of und wird nicht nur für Schleifen genutzt. Dieses Element hat nicht unbedingt etwas mit der for-each-Schleife zu tun, denn das Element wird nur dazu verwendet einen Eintrag auszuwählen. Wenn wir nun bspw. verschiedene Daten in einer XML-Datei speichern, können wir den Inhalt auch ausgeben, indem wir durch das Element angeben welche Daten ausgegeben werden sollen (Adressierung und Pfadangaben durch XPath). Bisher haben wir immer apply-templates verwendet um den Inhalt auszugeben, in Zukunft machen wir dies aber hauptsächlich mit value-of, da die apply-templates-Methode nicht so "professionell" ist. Das Element value-of ist einteilig und muss somit am Schluss mit /> gekennzeichnet werden. value-of hat 3 Attribute. Das erste Attribut, heißt select und ist eine Pflichtangabe. Mit select wird angegeben welcher Knoten ausgegeben werden soll. Ein weiteres Attribut ist extension-element-prefixes, damit kann ein Namensraum oder mehrere Namensräume angegeben werden. Diese Angabe sollte verwendet werden, wenn im XML-Dokument Namensräume verwenden werden. Bei der Angabe von mehreren Namensräumen, werden die verschieden Namen durch ein Leerzeichen getrennt. disable-ouput-escaping, ist ein weiteres Attribut, dass verwendet wird um die Steuerung der XML-eigenen Zeichen zu steuern. Mit der Angabe yes (Standard) werden Sie umgewandelt. Bei der Angabe no nicht. Hier ein kleines Einführungsbeispiel für die Ausgabe von Daten / Zeichenketten mit value-of:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslvalueof.xsl" type="text/xsl"?>
 
<freundesliste>
  <freund>Susanne</freund>
  <freund>Michaela</freund>
  <freund>Dieter</freund>
  <freund>Werner</freund>
  <freund>Stefanie</freund>
</freundesliste>
<?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="freundesliste/freund">
  <xsl:value-of select="." />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)


In dem vorherigen Beispiel ist zu sehen, dass auch ohne eine Schleife alle Elemente die den Namen "freund" haben ausgegeben werden, dies klappt jedoch nicht in jedem Fall. Manchmal muss die Adressierung einfach anders ablaufen, und die oben beschriebene Methode kann nicht angewendet werden. Selbst wenn es funktioniert, ist es nicht zu empfehlen die obere Variante zu verwenden um mehrere gleichnamige XML-Tags bzw. dessen Inhalt auszugeben. Die for-each-Schleife ist ein 2 teiliges Element welches mit for-each gekennzeichnet ist. Das Element besitzt lediglich 1 Attribut. Dies ist jedoch auch Pflicht. Mit dem Attribut select wird der Knoten / das Knoten-Set angegeben, in welchem sich die Elemente die ausgegeben werden sollen befinden. Übrigens: Die Inhalte der verschiedenen XML-Tags müssen selbstverständlich nicht alle der gleichen XML-Tag-Name besitzen, da eine Schleife, egal welchen Inhalt der Tag hat, alle untergeordneten Elemente (außer es wurde eine spezielle Anweisung gemacht -bspw. durch XPath-Funktionen) abarbeitet. Hierzu folgendes Beispiel:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslforeach.xsl" type="text/xsl"?>
 
<freundesliste>
  <freund>Susanne</freund>
  <freund>Michaela</freund>
  <freund>Dieter</freund>
  <freund>Werner</freund>
  <freund>Stefanie</freund>
</freundesliste>
<?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="freundesliste">
  <ul>
    <xsl:for-each select="freund">
      <li><xsl:value-of select="." /></li>
    </xsl:for-each>
  </ul>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Abfrage-Reihen

Eine Abfrage oder auch Abfrage-Reihen genannt, besteht aus 3 Elementen: choose - when - otherwise. Das Element choose ist das Hauptelement der Abfrage-Reihe und umgibt alle untergeordneten Befehle und Elemente. Das Element stellt keine Attribute zur Verfügung. Der Aufbau einer Abfrage-Reihe ist immer gleich: choose umgibt die Elemente when und otherwise. when darf beliebig oft auftreten, otherwise dagegen nur einmal und nach allen anderen when-Elementen. In when wird eine Bedingung gestellt. Diese Bedingung wird in das Attribut test eingesetzt. Zwischen den zwei Tags für when können nun Befehle hineingeschrieben werden, was passieren soll, wenn die Bedingung erfüllt ist. Wird die Bedingung nicht erfüllt, wird zum nächsten when-Element bzw. wenn nicht vorhanden zum otherwise-Element gesprungen. Das Element otherwise hat keine Attribute. Die Befehle zwischen seinen 2 Tags werden ausgeführt wenn keine der when-Bedingungen erfüllt wurde. Die Abfrage-Reihe läuft so oft durch bis alle Elemente im angegebenen Bereich abgearbeitet sind. In dem Beispiel wird ein Element namens variable verwendet. Dieses Element wird erst später genauer erklärt. Im Anzeigebeispiel ist zu sehen, dass alle Elemente die größer sind als 1000 grün gekennteichnet werden und alle die kleiner sind als 1000 rot gekennzeichnet werden. Hier nun das fertige Beispiel:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslabfrage.xsl" type="text/xsl"?>
 
<punkteliste>
  <punkte>1348</punkte>
  <punkte>841</punkte>
  <punkte>1729</punkte>
  <punkte>450</punkte>
  <punkte>942</punkte> 
</punkteliste>
<?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="punkteliste/punkte">
  <ul>
    <xsl:variable name="zahl" select="." />
    <xsl:choose>
      <xsl:when test="$zahl &gt; 1000">
        <li style="color: green;"><xsl:value-of select="." /></li>
      </xsl:when>
      <xsl:otherwise>
        <li style="color: red;"><xsl:value-of select="." /></li>
      </xsl:otherwise>
    </xsl:choose>
  </ul>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Der if-Befehl

Wie in vielen anderen Programmiersprachen auch, gibt es auch in XSLT den if-Befehl. Gekennzeichnet wird der Befehl mit xsl:if. Der if-Befehl bewirkt, dass wenn die gestellte Bedingung erfüllt wurde, ein bestimmtes Ereignis ausgeführt wird. Anders wie beispielsweise bei PHP gibt es keinen else-Befehl. Die Bedingung für den if-Befehl wird innerhalb vom Attribut test aufgeführt. In unserem Beispiel verwenden wir eine Highscore-Tabelle, die ähnlich aufgebaut ist wie die im vorherigen Beispiel. Aufgrund dessen, wie der if-Befehl abgearbeitet wird, haben wir jedoch eine kleinere Änderung vornehmen müssen (mal abgesehen davon, dass wir die Namen geändert haben, was man nicht hätte tun müssen). Im Beispiel werden die gleichen Zahlen wie vorhin verwendet. Im XSL-Dokument werden 2 Templates verwendet. Im 2. Template befindet sich der if-Befehl. Dieses Template läuft so oft durch, bis es am Ende des Dokumentes angelangt ist. Wenn nun das Element Punkte einen Wert besitzt der gleich oder größer als 1000 ist, wird für dieses Element eine eigene Aufzählungsliste mit einem einzigen Aufzählungspunkt erstellt.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslif.xsl" type="text/xsl"?>
 
<liste>
  <highscore>
    <punkte>1348</punkte>
  </highscore>
  <highscore>
    <punkte>841</punkte>
  </highscore>
  <highscore>
    <punkte>1729</punkte>
  </highscore>
  <highscore>
    <punkte>450</punkte>
  </highscore>
  <highscore>
    <punkte>942</punkte>
  </highscore>
</liste>
<?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="highscore">
  <xsl:if test="punkte &gt;= 1000">
    <ul>
      <li><xsl:value-of select="." /></li>
    </ul>
  </xsl:if>
</xsl:template>
</xsl:stylesheet>	
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



einfacher Zeicheninhalt

Auch XSLT stellt einen Befehl auf, mit dem einfach nur Text in der Ergebnisdatei erzeugt wird - ohne dass dieser Text vorher in einem XML-Element gespeichert worden ist. Das Element ist nicht wirklich etwas Besonderes, deshalb gibt es über dieses Element auch nicht sehr viel zu sagen. Das Element besitzt noch ein Attribut namens disable-output-escaping. Erlaubte Werte für dieses Attribut sind yes und no. Mit dem Attribut werden die XML-eigenen Zeichen gesteuert. Mit yes kann die Umwandlung von beispielsweise &lt nach < unterdrückt werden. Normalerweise ist der Umwandeln der Zeichen erlaubt, deshalb ist die Voreinstellung der Wert no. Ob man dieses Element, dass übrigens durch xsl:text markiert wird, unbedingt benötigt wird, oder ob man den Text einfach direkt reinschreibt ist ansichtsache. Hier ein Beispiel mit 2 verschiedenen Möglichkeiten Text auszugeben:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xsltext.xsl" type="text/xsl"?>
 
<name>Max Mustermann</name>
<?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>
    <p><xsl:text>Mein Name ist </xsl:text><xsl:apply-templates /><xsl:text>!</xsl:text></p>
    <p>Mein Name ist <xsl:apply-templates />!</p>
  </body></html> 
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Erzeugen eines Elements

Normalerweise erzeugen Sie Elemente, indem sie einfach den Elementnamen direkt eingeben, wie dies auch in den bisherigen Beispielen so gemacht wurde. Dies muss jedoch nicht so gemacht werden. Denn Elemente können auch durch das Element xsl:element erzeugt werden. Empfehlenswert und sinnvoll ist die Methode nur dann, wenn man Attribute und Attribut-Sets mit dem Element verknüpft. Das XSLT-Element besitzt 3 Attribute, wobei das Attribut name Pflicht ist, da es den Elementnamen im Ausgangsbaum angibt (z. B. p für das HTML-Element <p></p>). Mit dem Attribut namespace, kann der angehörige Namensraum des Elements angegeben werden. Das letzte und für diesen XSLT-Befehl vermutlich eines der wichtigsten Attribute ist use-attribute-sets, denn damit wird nämlich das Attribut-Set aufgerufen, welches für dieses Element verwendet werden soll. Hier nun ein einfaches Beispiel ohne Attribut-Sets. Als Beispiel nehmen wir ein bereits bekanntes XML-Beispiel vom Abschnitt "Abfrage-Reihen":

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslelement.xsl" type="text/xsl"?>
 
<punkteliste>
  <punkte>1348</punkte>
  <punkte>841</punkte>
  <punkte>1729</punkte>
  <punkte>450</punkte>
  <punkte>942</punkte> 
</punkteliste>
<?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="punkteliste/punkte">
  <ul>
    <xsl:element name="li"><xsl:value-of select="." /></xsl:element>
  </ul>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Erzeugen von Attributen

Gerade eben haben Sie gelernt, dass XSL Elemente mit einem bestimmen Befehl erzeugen kann, ohne Sie direkt zu notieren. Nun wird es aber sehr interessant, denn mit XSLT-Elementen können auch Attribute erstellt bzw. erzeugt werden. Oft wird dies jedoch kombiniert mit Abfrage-Reihen. Ein kleines Beispiel: Im XML-Dokument im Element xy gibt es das Attribut farbe mit dem Wert rot. Nun kann XSLT mit der Abfrage-Reihe bspw. überprüfen ob der Wert rot, gelb, blau oder grün ist. Wenn der Wert rot ist bekommt das Element im Ausgangsbaum das Attribut style überliefert. Als Wert für style wird dann bspw. background-color: red; gesetzt. So können nun alle möglichen Farben überprüft werden und im Attribut eingesetzt werden, dass alles geschieht mit einer Abfrage-Reihe und dem neuen Element xsl:attribute. Das Attribut name legt den Namen des Attributs fest. Da ohne Attributname kein Attribut erzeugt werden kann, ist dieses Attribut Pflicht. Der Wert des zu erzeugenden Attributs wird zwischen die 2 Tags geschrieben. Ein weiteres Attribut, dass dieses XSLT-Element zur Verfügung stellt ist namespace. Als Wert wird der URI des zu dem Attribut stammenden Namensraums angegeben. Nun können Sie schon Mal einzelne Attribute erzeugen, wie man ganze Sets erstellen kann, darauf gehen wir gleich näher ein. Doch zunächst erst mal ein einfaches Beispiel:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslattribut1.xsl" type="text/xsl"?>
 
<text>
  <absatz farbe="rot">Dies ist ein Block. Wenn alles richtig funktioniert hat, wird er rot gefärbt!</absatz>
  <absatz farbe="gelb">Dies ist ein Block. Wenn alles richtig funktioniert hat, wird er gelb gefärbt!</absatz>
  <absatz farbe="blau">Dies ist ein Block. Wenn alles richtig funktioniert hat, wird er blau gefärbt!</absatz>
  <absatz farbe="grün">Dies ist ein Block. Wenn alles richtig funktioniert hat, wird er grün gefärbt!</absatz>
</text>
<?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/absatz">
  <div>
    <xsl:choose>
      <xsl:when test="@farbe='rot'">
        <xsl:attribute name="style">background-color: red;</xsl:attribute>
      </xsl:when>
      <xsl:when test="@farbe='gelb'">
        <xsl:attribute name="style">background-color: yellow;</xsl:attribute>
      </xsl:when>
      <xsl:when test="@farbe='blau'">
        <xsl:attribute name="style">background-color: blue;</xsl:attribute>
      </xsl:when>
      <xsl:when test="@farbe='grün'">
        <xsl:attribute name="style">background-color: green;</xsl:attribute>
      </xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="style">background-color: red;</xsl:attribute>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:value-of select="." />
  </div>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)


Nun haben Sie schon einen kleinen Einblick in das Erstellen von Attributen bekommen. Nun gibt es noch, wie bereits vorher schon erwähnt, die sogenannten Attribut-Sets. Attribut-Set bedeutet nicht unbedingt, dass man mehr als 1 Attribut setzt, denn Attribut-Sets sind dafür gedacht, dass wenn man eine bestimmte Reihe von Attributen oder ein einziges Attribut mehrmals verwenden möchte. Attribut-Sets stehen außerhalb von Template-Anweisungen oder anderen. Sie werden also nicht direkt in einem bestimmten Bereich angewendet, sondern werden über die Elemente element oder copy (dazu später mehr) aufgerufen. Das XSLT-Element wird durch die Tags xsl:attribute-sets gekennzeichnet und besitzt insgesamt 2 Attribute. Das 1. Attribut, dass als Pflicht-Attribut gilt, lautet name und legt den Attribut-Set-Namen fest. Über diesen Attribut-Set-Namen kann es später mit xsl:element oder xsl:copy aufgerufen werden. Ein weiteres Attribut ist use-attribute-sets mit dem weitere Attribut-Sets mit dem aktuellen Attribut-Set verknüpft werden können. Dies ist vor allem bei sehr großen Projekten sinnvoll. Natürlich könnte man, dass ganze auch wieder mit einer Abfrage vornehmen. Folgendes Beispiel haben wir dazu für Sie gemacht:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslattribut2.xsl" type="text/xsl"?>
 
<text>
  <absatz formatierung="titel">Haupt-Titel</absatz>
  <absatz formatierung="untertitel">Untertitel 1</absatz>
  <absatz formatierung="text">Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text.</absatz>
  <absatz formatierung="untertitel">Untertitel 2</absatz>
  <absatz formatierung="text">Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text.</absatz>
  <absatz formatierung="untertitel">Untertitel 3</absatz>
  <absatz formatierung="text">Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text. Hier steht der Text.</absatz>
  <absatz formatierung="123">Wenn die Formatierung funktioniert, wird dieser Teil nicht ausgegeben!</absatz>
</text>
<?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:attribute-set name="titel">
  <xsl:attribute name="style">font-family: Arial; font-size: 27px; font-weight: bold;</xsl:attribute>
  <xsl:attribute name="align">left</xsl:attribute>
</xsl:attribute-set>
 
<xsl:attribute-set name="untertitel">
  <xsl:attribute name="style">font-family: Times; font-size: 20px;</xsl:attribute>
  <xsl:attribute name="align">left</xsl:attribute>
</xsl:attribute-set>
 
<xsl:attribute-set name="text">
  <xsl:attribute name="style">font-family: sans-serif; font-size: 18px;</xsl:attribute>
  <xsl:attribute name="align">justify</xsl:attribute>
</xsl:attribute-set>
 
<xsl:attribute-set name="leer">
  <xsl:attribute name="style">display: none;</xsl:attribute>
</xsl:attribute-set>
 
<xsl:template match="text/absatz">
  <xsl:choose>
    <xsl:when test="@formatierung='titel'">
      <xsl:element name="h1" use-attribute-set="titel"><xsl:value-of select="." /></xsl:element>
    </xsl:when>
    <xsl:when test="@formatierung='untertitel'">
      <xsl:element name="h3" use-attribute-set="untertitel"><xsl:value-of select="." /></xsl:element>
    </xsl:when>
    <xsl:when test="@formatierung='text'">
      <xsl:element name="p" use-attribute-set="text"><xsl:value-of select="." /></xsl:element>
    </xsl:when>
    <xsl:otherwise>
      <xsl:element name="div" use-attribute-set="leer"></xsl:element>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Sortieren nach Inhalt

XSLT stellt unter anderem auch ein Sortierungs-Element zur Verfügung. Das Element ist einteilig und wird mit xsl:sort gekennzeichnet. Das Element ist dazu fähig Knoten nach dem Inhalt zu sortieren. Wie der Inhalt sortiert werden soll, kann mit Attributen eingestellt werden. Bei keinem, von diesen, handelt es sich jedoch um ein Pflichtattribut. Mit data-type wird festgelegt ob eine numerische Sortierung (number) oder eine alphabetische Sortierung (text), bei der es sich um die Voreinstellung handelt, erfolgen soll. Das Attribut order legt fest ob aufsteigend (ascending) oder absteigend (descending) sortiert werden soll. Die aufsteigende Sortierung ist die Standardeinstellung. Des Weiteren lassen sich auch noch die Sortierung von Groß- und Kleinbuchstaben steuern. Der Wert lower-first legt fest, dass Kleinbuchstaben vor Großbuchtstaben kommen. upper-first bedeutet, dass Großbuchstaben vor Kleinbuchstaben kommen. Wer zusätzlich noch eine Sprachsteuerung benötigt kann mit dem Attribut lang die Sprache für die Sprachkonvention festlegen. Die Konventionen gehen nach RFC 1766, d. h. bspw. deutsch wird abgekürzt mit de. Normalerweise wird xsl:sort in xsl:for-each notiert. Ob xsl:sort überhaupt außerhalb von xsl:for-each in jedem Browser funktioniert ist nicht wirklich bekannt.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslsort.xsl" type="text/xsl"?>
 
<kontaktbuch>
  <kontakt>Ungut, Lisa</kontakt>
  <kontakt>Treu, Charlotte</kontakt>
  <kontakt>Meyer, Sebastian</kontakt>
  <kontakt>Süss, Heike</kontakt>
  <kontakt>Schnell, Heiner</kontakt>
</kontaktbuch>
<?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="kontaktbuch">
  <ul>
  <xsl:for-each select="kontakt">
    <xsl:sort data-type="text" case-order="upper-first" />
    <li><xsl:value-of select="." /></li>
  </xsl:for-each>
  </ul>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



definieren von Parametern und zuweisen von Parameter-Werten

Parameter sind vergleichbar mit Variablen. Sie sind dafür gedacht Werte zu speichern und aufzurufen. Parameter sind jedoch noch ein wenig flexibler. Um mit Parametern zu arbeiten, benötigen wir 2 Elemente: param und with-param Normalerweise handelt es sich bei den Elementen um einteilige Codes, jedoch können diese, genauso wie (fast) alle anderen XSLT-Elemente auch zweiteilig verwenden werden. Sie sollten sich an dieser Aussage auf jeden Fall erkennen, dass XSL eine relative freie Sprache ist und ob man letztendlich <xsl:param /> oder <xsl:param></xsl:param> schreibt ist relativ egal. Mit dem Element param wird ein Parameter definiert. Das Element besitzt 2 Attribute: name und select. Mit dem name-Attribut wird der Name der Parametervariabel vergeben. Das Attribut ist Pflicht und muss in jedem Fall verwendet werden. Ein weiteres Attribut ist select mit dem ein Default-Wert gesetzt werden kann. Nun benötigen wir noch das with-param Element, mit dem einem Parameter ein Wert zugewiesen wird. Der Wert wird standardmäßig beim Aufruf eines Templates (call-template) zugewiesen. Durch die Wertzuweisung zu einem bestimmten Parameter, kann der Parameter nun weiterverendet werden. Dafür muss man vor den Parameternamen einfach ein Dollarzeichen setzen. Das Dollarzeichen wird auch bei den Variablen verwendet, dazu später mehr. xsl:with-param bietet ebenfalls wieder 2 Attribut namens name und select. Das Attribut name ist ebenfalls wieder Pflicht und gibt den Namen des Parameters an. Das select Attribut legt nun jedoch keinen Default-Wert fest, sondern bestimmt entweder eine Pfadangabe, eine Rechnung oder aber auch statischen Text (in einfachen Anführungszeichen). In unserem XML-Beispiel werden ein Startwert und ein Endwert festgelegt. Das XSL-Dokument besteht aus dem Haupt-Template, welches ein Template namens liste aufruft. Zwischen den zwei call-template Tags befindet sich das xsl:with-param Element, welches den Startwert unseres XML-Dokument zugewiesen bekommt. Im Template mit dem Namen liste wird nun der Parameter definiert. Darunter befindet sich nun eine Abfrage-Reihe. Es wird überprüft ob der jetzige Wert kleiner oder gleich dem Endwert der XML-Datei ist. Wenn dies der Fall ist, wird die Zahl ausgegeben (in einer Liste) und mit xsl:with-param innerhalb eines weiteren xsl:call-template Elements der Parameter-Wert um 7 erhöht. Nun läuft dieses Template ein weiteres Mal durch und es beginnt die Ausgabe, die Erhöhung des Werts und der nochmalige Aufruf des Templates. Wenn nun der nächste Wert größer als der Endwert in der XML-Datei ist, kommt das xsl:otherwise Element in Einsatz. Zwischen den xsl:otherwise Elementen ist kein Befehl notiert, d. h. also wenn der Wert im Vergleich zum Endwert in der XML-Datei überschritten wird, passiert nichts mehr.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslparam.xsl" type="text/xsl"?>
 
<liste>
 <startnummer>49</startnummer>
 <endnummer>266</endnummer>
</liste>
<?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:call-template name="liste">
      <xsl:with-param name="parameter" select="liste/startnummer" />
    </xsl:call-template>
  </ul>
  </body></html>
</xsl:template>
 
<xsl:template name="liste">
  <xsl:param name="parameter" />
  <xsl:choose>
    <xsl:when test="$parameter &lt;= liste/endnummer">
      <li><xsl:value-of select="$parameter" /></li>
      <xsl:call-template name="liste">
        <xsl:with-param name="parameter" select="$parameter + 7" />
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Elemente und beliebige Daten kopieren

XSL stellt 2 verschiedene Elemente zur Verfügung mit denen etwas kopiert werden kann. Das 1. Element ist copy, diess kann ein Element kopieren und im Ereignisbaum einsetzt. Dabei werden die Tags und der Zeicheninhalt kopiert. Es werden jedoch keine Kinderelemente und Attribute kopiert. Jedoch kann man dem copy Element noch ein Attribut-Set hinzufügen. Das Attribut-Set kann zum Element xsl:copy mit dem Attribut use-attribute-sets angeheftet werden. Zwischen den 2 xsl:copy Tags können nun verschiedene Anweisungen gemacht, bei dem fast alle bisher bekannten XSLT-Elemente benutzt werden dürfen. Das einfachste Beispiel ist die Auswahl eines Elements mit xsl:value-of. Im Beispiel hat das Element im XML-Dokument den Namen h1. Da das XSL-Template die Daten in HTML verarbeitet, muss man natürlich einen Namen verwenden, den HTML kennt.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslcopy.xsl" type="text/xsl"?>
 
<h1>Max Mustermann</h1>
<?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="h1">
  <xsl:copy><xsl:value-of select="." /></xsl:copy>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)


Das 2. Kopierelement in XSL ist copy-of, mit dem ebenfalls ein Element kopiert werden kann und in der Ereignisbaum geschrieben wird. Im Gegensatz zu xsl:copy ist es dazu gedacht, mehrmals an verschiedenen Stellen eingesetzt zu werden. Anders wie bei xsl:copy ist der Inhalt der kopiert wird. xsl:copy-of kopiert auch den Zeicheninhalt des aktuellen Knotens. Des Weiteren werden aber noch Unterknoten kopiert, d. h. also es wird der Knoten und das davon abhängige Knoten-Set kopiert. Der Knoten bzw. das Knoten-Set kann mit dem Attribut select ausgewählt werden. xsl:copy-of ist im Gegensatz zu xsl:copy einteilig. In unserem Beispiel wird eine "Hausverwaltungs-Tabelle" erstellt. Der Titel dazu wird immer in die vordere Spalte der Tabelle kopiert, und das passiert eben mit dem Element xsl:copy-of Das Beispiel erklärt sich sonst von selbst:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslcopy2.xsl" type="text/xsl"?>
 
<hausverwaltung>
  <titel>HAUSVERWALTUNG</titel>
  <mitarbeiter>
    <name>Wolfgang Müller</name>
    <position>Hausmeister</position>
    <telefon>01234 - 56789 - 1</telefon>
  </mitarbeiter>
  <mitarbeiter>
    <name>Herbert Meyer</name>
    <position>Stellv. Hausmeister</position>
    <telefon>01234 - 56789 - 2</telefon>
  </mitarbeiter>
  <mitarbeiter>
    <name>Lisa Schäfer</name>
    <position>Reinigungsfachkraft</position>
    <telefon>01234 - 56789 - 3</telefon>
  </mitarbeiter>
  <mitarbeiter>
    <name>Gerd Schmidt</name>
    <position>Gärtner</position>
    <telefon>01234 - 56789 - 4</telefon>
  </mitarbeiter>
</hausverwaltung>
<?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">
    <tr>
      <th></th>
      <th><b>Name</b></th>
      <th><b>Position</b></th>
      <th><b>Telefonnummer</b></th>
    </tr>
    <xsl:apply-templates />
  </table>
  </body></html>
</xsl:template>
 
<xsl:template match="hausverwaltung/mitarbeiter">
  <tr>
    <td><b><xsl:copy-of select="../titel" /></b></td>
    <xsl:apply-templates />
  </tr>
</xsl:template>
 
<xsl:template match="name">
  <td><xsl:value-of select="." /></td>
</xsl:template>
 
<xsl:template match="position">
  <td><xsl:value-of select="." /></td>
</xsl:template>
 
<xsl:template match="telefon">
  <td><xsl:value-of select="." /></td>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Nummerierung

Oft wird es benötigt, bestimmte Knoten mit dem gleichen Namen nicht nur auszugeben, sondern gleichzeitig auch zu nummerieren. Hilfe dafür bietet das Element number. Mit dem Element kann viel gemacht werden, da es insgesamt 9 Attribute bietet. Das wohl wichtigste Attribut ist count, mit dem werden nämlich die Knoten ausgewählt, die das Nummerierungselement beachten soll. Ein weiteres Element, das zu count dazugehört ist from. Das Attribut from bestimmt den Knoten, bei dem der Nummerierungsvorgang beendet werden soll. Auch die Trennzeichen bei der Nummerierung können bestimmt werden. Trennzeichen sind dafür gedacht, um bessere Übersicht zu schaffen, bspw. Tausendertrennzeichen. Dazu stellt das Element 2 Attribute zur Verfügung grouping-separator und grouping-size. Das Attribut grouping-separator bestimmt das Trennzeichen-Symbol, also z. B. ein Punkt. Das andere Attribut stellt ein, nach wie vielen Ziffern ein Trennzeichen gesetzt werden sollen. Wer noch die Sprache festlegen möchte der kann mit dem lang-Attribut nach RFC 1766 die Sprache festlegen. Ein weiteres sehr wichtiges Attribut ist format mit dem die Art der Nummerierung festgelegt werden kann. Als Wert sind verschiedene Angaben möglich: 1 (Zahlen) - 01 (Zahlen - wenn Sie kleiner als null sind, wird eine Null davor gesetzt) - a (Kleinbuchstaben) - A (Großbuchstaben) - i (römische Kleinzahlen) - I (römische Großzahlen). Die Angabe kann noch erweitert werden, z. B. durch einen Punkt oder ein Leerzeichen. Auch andere Zeichen sind denkbar. Bei manchen Sprachen ist es sinnvoll zusätzlich die Angabe letter-value zu machen. Das Attribut hat zwei Werte die erlaubt sind: traditional und alphabetical. Wer in seine Nummerierung noch Kalkulationen mit ein bauen möchte, der kann Verwendung mit dem Attribut value haben. Meistens werden XPath-Funktionen eingesetzt. Das letzte Attribut, welches das Element hat, ist level. Mögliche Werte im level-Attribut sind any, single und multiple. Der Wert any und single bewirkt fast das gleiche: Es können Nummerierungen mit einer fortlaufenden Nummer / Buchstabe erzeugt werden. Der Wert any hat im Gegensatz zu single noch eine Sonderfunktionen, denn any arbeitet zusätzlich noch mit den übergeordneten Ebenen und es wird geprüft ob die count-Abgabe auf den Knoten zutrifft. Dabei werden dann alle letztendlich alle Knoten zusammengezählt. Der Unterschied ist jedoch nicht so einfach zu erklären. Der Wert multiple hat jedoch ganz andere Funktionen. Im Gegensatz zu den anderen Werten arbeitet der Algorithmus nicht nur über die aktuelle Ebene, sondern auch auf allen übergeordneten Ebenen. Die Nummerierung muss nicht mehr nach dem Schema 1, 2, 3, 4, 5, ... erfolgen, sondern kann auch Unterpunkte besitzen (also 1.1, 1.2, ...) und somit eine hierarchische Strukturierung haben. Wer nun bspw. eine zweiteilige Nummerierung dieser Art haben möchte, der kann im count-Attribut auch noch andere Muster notieren, wie bspw. count="kapitel|thema". Die erste Zahl entspricht dann immer der Kapitelnummern und die 2. dem Thema in diesem Kapitel. Dabei werden die 2 Namen durch Senkrechtstriche geteilt. Mit dem Wert multiple kann man also ganz viel machen. In unserem Beispiel wird ein Einkaufliste nummeriert:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslnumber.xsl" type="text/xsl"?>
 
<einkaufsliste>
  <produkt>Knäckebrot</produkt>
  <produkt>Marmelade</produkt>
  <produkt>Ketchup</produkt>  
  <produkt>Butter</produkt>
  <produkt>Milch</produkt>
  <produkt>Äpfel</produkt>
  <produkt>Zucker</produkt>
  <produkt>Mehl</produkt>
  <produkt>Schokolade</produkt>
  <produkt>Kekse</produkt>
  <produkt>Karotten</produkt>
  <produkt>Tomaten</produkt>
  <produkt>Bananen</produkt>
</einkaufsliste>
<?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="produkt">
  <xsl:number count="produkt" format="a) " level="single" />
  <xsl:value-of select="." /><br />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Steuerung des Ergebnisbaums

Wie sie bereits erkannt haben, hat XSLT viele Funktionen. Unter anderem kann auch die Erzeugung des Eregbnisbaums gesteuert werden. Dazu wird das einteilige Element output verwendet. Durch verschiedene Attribute können nun verschiedene Einstellung vorgenommen werden. Das wohl wichtigste Attribut ist method, mit dem die Konventierungssprache ausgewählt werden kann. Die Voreinstellung ist html. Andere mögliche Werte sind xml, text oder andere. Mit "andere", sind weitere eigene oder öffentliche XML-Namensräume gemeint. Das Attribut encoding gibt die Kodierung nach RFC 2978. Wenn beim Attribut method als Wert xml angegeben worden ist, kann das Attribut cdata-section-elements verwendet werden. Dort können Elemente angegeben werden die in CDATA-Abschnitte umgewandelt werden sollen. Mehrere Elementnamen trennt man durch Leerzeichen. Eine schicke Funktion für Personen die DTDs verwenden sind die Attribute doctype-public und doctype-system. Wenn sich die Gültigkeitsprüfung auf eine öffentliche DTD bezieht, wird das Attribut doctype-public mit dem Wert public identifiers verwendet. Wenn Sie eine adressierte DTD benutzen, dann verwenden Sie das Attribut doctype-system mit dem Wert system identifiers. Die 2 genannten Attribute dürfen jedoch nur verwendet werden, wenn das Attribut method den Wert xml oder html hat. Ein weiteres Attribut ist ident, mit diesem kann gesteuert werden ob untergeordnete Elemente im Ergebnisbaum eingerückt werden sollen. Die möglichen Werte sind yes und no. yes bewirkt, dass die Elemente eingerückt werden. Wer das möchte, kann mit dem Attribut media-type den MIME-Typ festlegen. Wer bei dem method-Attribut den Wert xml verwendet kann noch zusätzlich mit dem Attribut omit-xml-declaration festlegen, ob die XML-Deklaration im Ergebnisbaum weggelassen werden soll. Der Wert yes bedeutet, dass die XML-Deklaration weggelassen wird. Der Wert no bedeutet, dass die Deklaration nicht weggelassen wird. Wer bei diesem Attribut den Wert no setzt kann mit den Attributen version und standalone weitere Einstellungen vornehmen. Wer jetzt genau aufgepasst hat, der merkt, dass das Attribut version und standalone normalerweise im XML-Root-Element verwendet wird, und genau diese Funktion haben die 2 Attribute. Warum die Attribute nur verwendet werden können, wenn omit-xml-declaration="no" notiert ist erklärt sich somit ebenfalls von selbst. Das war es auch schon. Bitte denken Sie daran, dass Sie das Element als direktes Kinderelement von xsl:stylesheet notiert werden muss.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xsloutput.xsl" type="text/xsl"?>
 
<dokument>
  <seitentitel>E-Mail-Verteiler von "Firma XY"</seitentitel>
  <main>
    <person>
      <name>Lisa</name>
      <email>lisa@firmaxy.com</email>
    </person>
    <person>
      <name>Peter</name>
      <email>peter@firmaxy.com</email>
    </person>
    <person>
      <name>David</name>
      <email>david@firmaxy.com</email>
    </person>
  </main>
</dokument>
<?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" encoding="ISO-8859-1" ident="yes" omit-xml-declaration="no" version="1.0" />
 
<xsl:template match="/dokument">
  <verteiler>
    <xsl:for-each select="main/person">
    <kontakt>
      <vorname><xsl:value-of select="name" /></vorname>
      <emailadresse><xsl:value-of select="email" /></emailadresse>
    </kontakt>
    </xsl:for-each>
  </verteiler>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel



Variablen

XSLT hat ein Element zum Speichern von Variablen. Ein XSLT-Variable-Element ist ganz einfach. Es ist einteilig und hat nur 2 Attribute. Das Attribut name ist Pflicht und vergibt den Namen der Variable. Mit diesem Namen wird später die Variable aufgerufen oder mit dieser weitergearbeitet. Jetzt kann man zusätzlich noch den Wert für die Variable bestimmen. Dies geschieht mit dem Attribut select. Mit select wird jedoch nicht wirklich ein Wert angegeben, sondern nur der Pfad zu einem XML-Element. Das select-Attribut ist deshalb keine Pflicht, da es oft durch Template-Definitionen so eingeschränkt wird und es in Template-Definitionen verwendet wird. Wird das Element variable, so heißt das Element zum Erstellen von Variablen, außerhalb einer Template-Definition notiert, so ist das select-Attribut Pflicht bzw. notwendig für den korrekten Gebrauch. Wird eine Variable außerhalb einer Template-Definition verwendet spricht man von einer globalen Variabel. Im Vergleich zu den Parametern, sind Variablen viel einfacher zu benutzen. Parameter werden vor allem dann verwendet, wenn ein Zahlenwert gespeichert werden soll und durch verschiedene Schleifen oder Abfragen um bestimmte Werte erhöht werden sollen. Variablen dagegen nutzt man eher nur zum einfachen Speichern vor Werten oder Texten. Der Wert einer Variable kann bspw. durch xsl:value-of mit dem Attribut select ausgegeben werden. Als Wert von select verwendet man den Namen der Variabel und setzt davor ein Dollarzeichen. Diese Notation gilt jedoch nicht nur für die Ausgabe, sondern auch bei dem Weiterarbeiten mit der Variable, wie bspw. in Schleifen oder Abfragen.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslvariable.xsl" type="text/xsl"?>
 
<liste>
  <highscore>
	<punkte>1348</punkte>
  </highscore>
  <highscore>
	<punkte>841</punkte>
  </highscore>
  <highscore>
	<punkte>1729</punkte>
  </highscore>
  <highscore>
	<punkte>450</punkte>
  </highscore>
  <highscore>
	<punkte>942</punkte>
  </highscore>
</liste>
<?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="highscore">
  <xsl:variable name="wert" select="punkte" />
  <p><xsl:value-of select="$wert" /></p>
</xsl:template>
</xsl:stylesheet>	
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Leerraum und Leerzeichen steuern

Oftmals wird in den XML-Dokumenten eine sichtbare Baumstruktur erstellt, d. h. untergeordnete Elemente werden bspw. um 2 Leerzeichen weiter nach rechts eingerückt. XML ignoriert das normalerweise. In der Computertechnik gibt es die sogenannten Leerraumzeichen. Als Leerraumzeichen gelten Leerzeichen, aber auch Tabulatorzeichen, Zeilenvorschubs-Zeichen und Wagenrücklaufzeichen. XSLT bietet für die Steuerung der Leeraumzeichen 2 Elemente zur Verfügung. xsl:strip-space und xsl:preserve-space. Beide Elemente sind völlig gleich aufgebaut. Beide besitzen nur ein Attribut, welches jedoch ein Pflichtattribut ist: elements - Mit elements werden die Elemente ausgewählt, bei welchen die Leerraumzeichen ignoriert oder nicht ignoriert werden sollen. Das Element xsl:strip-space behält die Leeraumzeichen nicht bei. Ob man dieses Element also wirklich braucht, kann man nicht wirklich sagen. Das Element xsl:preserve-space bewirkt das Gegenteilige. Bei diesem Element ist jedoch zu beachten, dass in HTML mehr als 1 Leerzeichen nicht akzeptiert wird. Um also die Auswirkung von xsl:preserve-space sichtbar zu machen, verwenden nicht einfach einen normalen Text-Absatz sondern das HTML-Element pre. Die Besonderheit bei pre ist, dass alle einzelne Leerraumzeichen (auch wenn Sie nacheinander kommen) akzeptiert und übersetzt werden. Wir haben dazu folgende 2 Beispiele (1. Beispiel mit xsl:strip-space - 2. Beispiel mit xsl:preserve-space):

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslspace.xsl" type="text/xsl"?>
 
<space>
 
 
  <element>Testnachricht...</element>
</space>
<?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>
  <pre><xsl:apply-templates /></pre>
  </body></html>
</xsl:template>
 
<xsl:strip-space elements="space" />
 
<xsl:template match="element">
  <xsl:value-of select="." />
</xsl:template>
</xsl:stylesheet>	
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)


<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslspace2.xsl" type="text/xsl"?>
 
<space>
 
 
  <element>Testnachricht...</element>
</space>
<?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>
  <pre><xsl:apply-templates /></pre>
  </body></html>
</xsl:template>
 
<xsl:preserve-space elements="space" />
 
<xsl:template match="element">
  <xsl:value-of select="." />
</xsl:template>
</xsl:stylesheet>	
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Verarbeitungshinweise im Ergebnisbaum

Auch für die Erstellung von Verarbeitungshinweisen im Ergebnisbaum gibt es in XSLT einen Befehl. Der Befehl lautet xsl:processing-instruction. Das Element hat nur ein Attribut mit dem Namen name. name gibt den Name des Verarbeitungshinweises an. Normalerweise bzw. oft wird dieses Element dazu verwendet ein weiteres Stylesheet-Dokument, jedoch meistens eine CSS-Datei, einzubinden. Aber natürlich auch andere Verarbeitungshinweise sind möglich. Das Element wird zweiteilig verwendet. Zwischen den 2 Tags dieses Elements wird meistens das Element xsl:text verwendet um noch den eigentlichen Teil einzugeben. Das Element ist jedoch nicht nötig. Bei dem XSL-Stylesheet werden als Zeicheninhalt die Quelle des Dokumentes und der MIME-Typ festgelegt. Hier dazu der folgende Beispiel-Code. Die Kompatibilität ist jedoch sehr eingeschränkt, deshalb gibt es hier kein Anzeigebeispiel. Der 1. Code zeigt den XSLT-Befehl. Der 2. Code zeigt das Ergebnis.

<xsl:processing-instruction name="xml-stylesheet">
href="style.css" type="text/css"
</xsl:processing-instruction>
<?xml-stylesheet href="style.css" type="text/css"?>

Dezimalzahlen

Für die genaue Einstellung bestimmter Zahlen bietet XSL das Element decimal-format. Das Element kann ein Schema für Dezimalzahlen definieren. Durch die XPath-Funktion format-number() kann das definierte Schema aufgerufen werden. Das XSLT-Element hat viele verschiedene Attribute. Das Attribut name vergibt dem Schema einen Namen. Über diesen Namen kann die Formatierung später aufgerufen werden. Die weiteren Attribute sind dieser Tabelle zu entnehmen:

Name Beschreibung Voreinstellung
decimal-separator Trennzeichen zwischen Ganzzahlen und Nachkommastellen .
grouping-separator Trennzeichen für eine Gruppe von Zahlen - Tausendertrennzeichen ,
pattern-separator Zeichen zwischen positiven und negativen Formatdarstellungen ;
minus-sign Zeichen welches vor einer negativen Zahl platziert wird -
infinity Zeichen(kette) die unendliche Werte repräsentiert Infinity
NaN Zeichen(kette) die angezeigt wird, wenn es sich um ungültige Zeichen handelt NaN
digit Platzhalter für eine unbekannte Ziffer #
zero-digit Zeichen für führende Nullen 0
percent Zeichen zur Kennzeichnung von Prozentwerten %
per-mille Zeichen zur Kennzeichnung von Promillewerten %O

xsl:decimal-format muss als direktes Kinderelement von xsl:stylesheet notiert werden. Die Funktion format-number() wird im Element xsl:value-of im select-Attribut notiert. In der Klammer werden insgesamt 3 Werte notiert. Der 1. Wert gibt den Knoten an, für den das Schema gelten soll. Der nächste Wert gibt die Formatregel an und der letzte Wert den Namen des im xsl:decimal-format-Elements definierten Namen. Die XPath-Funktion format-number() wird später genauer erklärt.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xsldecimal.xsl" type="text/xsl"?>
 
<liste>
  <wert>178922</wert>
  <wert>4652493315</wert>
  <wert>756z</wert>
  <wert>356</wert>
  <wert>94458</wert>
</liste>
<?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="sonderformat" decimal-separator="," grouping-separator="." NaN="Das ist keine Nummer..." />
 
<xsl:template match="/">
  <html><head></head><body>
  <xsl:apply-templates />
  </body></html>
</xsl:template>
 
<xsl:template match="wert">
  <xsl:value-of select="format-number(., '#.##0,#', 'sonderformat')" /><br />
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Bearbeitungsmeldungen und Kommentare

XSLT bietet 2 verschiedene Elemente, wobei eines für Bearbeitungsmeldungen gedacht ist und das andere für Kommentare. Das Bearbeitungsmeldungs-Element hießt message und gibt während des Transformations-Vorgangs eine Nachricht aus. Das Element besitzt ein Attribut mit dem Namen terminate. Das Attribut terminate legt fest ob der Transformations-Vorgang nach Erscheinen dieser Meldungen angehalten werden soll oder fortgeführt werden soll. Die möglichen Werte sind yes (= Abbrechen) und no (= nicht Abbrechen). Die Voreinstellung ist no. Das Element wird in der Praxis normalerweise nicht angewendet, sondern nur für Tests genutzt. Die mangelnde Browser-Unterstützung ist jedoch ebenfalls ein großes Problem. Das Element comment kann programmiersprachengerechte Kommentare setzen. Dieses Element besitzt keinerlei Attribute. Beide Elemente sind zweiteilig. Hier ein Beispiel, indem beide Elemente verwendet werden:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslmessage.xsl" type="text/xsl"?>
 
<wurzel>
  <text>Dieser Inhalt wird ausgegeben!</text>
  <kommentar>Dieser Inhalt wird nicht ausgegeben!</kommentar>
  <message>Die Transformation war erfolgreich!</message>
</wurzel>
<?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:value-of select="." /></p>
</xsl:template>
 
<xsl:template match="kommentar">
  <xsl:comment><xsl:value-of select="." /></xsl:comment>
</xsl:template>
 
<xsl:template match="message">
  <xsl:message><p><xsl:value-of select="." /></p></xsl:message>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



definieren von Zugriffsschlüsseln

In XSL können sogenannte Zugriffschlüssel definiert werden. Zugriffsschlüssel sind hauptsächlich für das schnellere Bearbeiten des XML- und XSL-Dokumentes gedacht. Um Zugriffsschlüssel zu verwenden, gibt es in XSLT ein Element namens key. Dort wird ein bestimmter Knoten oder ein Knoten-Set mit dem match-Attribut ausgewählt. Das Attribut ist jedoch nicht Pflicht. Ein weiteres Attribut ist use. use gibt ein Element oder Attribut an, auf welches sich der Zugriffsschlüssel bezieht. Dies ist ein Pflichtattribut. Natürlich muss man auch noch einen Namen für diesen Zugriffschlüssel vergeben. Dies geschieht mit dem name-Attribut. Um auf den Zugriffschlüssel zugreifen zu können benötigen wir die XPath-Funktion key() - dazu später mehr. Innerhalb der Klammer werden zwei Werte notiert. Der 1. Wert ist der Name des vorher definierten Zugriffsschlüssels. Der 2. Wert gibt den Wert des Attributs oder den Inhalt des Elements an, der vorausgesetzt wird um bspw. die Bedingung in einer Anweisung zu erfüllen.

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslkey.xsl" type="text/xsl"?>
 
<liste>
  <mitarbeiter art="vorstand" name="Heinz Müller" />
  <mitarbeiter art="arbeiter" name="Christina Herzer" />
  <mitarbeiter art="vorstand" name="Wolfgang Scherer" />
  <mitarbeiter art="arbeiter" name="Hans Schmid" />
  <mitarbeiter art="arbeiter" name="Maria Hillberg" />
</liste>
<?xml version="1.0" encoding="ISO-8859-1"?>
 
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 
<xsl:key match="mitarbeiter" use="@art" name="auswahl" />
 
<xsl:template match="/">
  <html><head></head><body>
    <xsl:for-each select="key('auswahl','vorstand')">
      <xsl:value-of select="@name" />
      <br />
    </xsl:for-each>
  </body></html>
</xsl:template>
</xsl:stylesheet>	
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Alternativanweisungen

Eine sehr praktische Funktion in XSL ist die sogenannte Alternativanweisung. Die Alternativanweisung wird innerhalb eines Elementes verwendet, für die die Alternativanweisung gelten soll. Das Element ist zweiteilig und heißt fallback. Innerhalb dieses Elements können alle möglichen Dinge notiert werden, andere XSLT-Elemente aber auch einfach nur Text. Das Element hat keine Attribute. Alternativanweisungen werden angezeigt, wenn der Browser das XSLT-Element nicht unterstützt. Hier nun ein einfaches Beispiel:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<?xml-stylesheet href="xslfallback.xsl" type="text/xsl"?>
 
<freundesliste>
  <freund>Susanne</freund>
  <freund>Michaela</freund>
  <freund>Dieter</freund>
  <freund>Werner</freund>
  <freund>Stefanie</freund>
</freundesliste>
<?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="freundesliste">
  <ul>
    <xsl:for-each select="freund">
      <xsl:fallback><p>Ihr XSLT-Prozessor unterstüzt diesen Befehl nicht!</p></xsl:fallback>
      <li><xsl:value-of select="." /></li>
    </xsl:for-each>
  </ul>
</xsl:template>
</xsl:stylesheet>
Anzeigebeispiel
Anzeigebeispiel (XML-Datei)



Anzeigebeispiel
Anzeigebeispiel (HTML-Datei)



Design:
 


Logo
Benjamin Jung
Krummstr. 9/3
73054 Eislingen

E-Mail: info@homepage-webhilfe.de
Webseite: www.homepage-webhilfe.de