SELFHTML/Navigationshilfen XML/DTDs Darstellung von XML-Daten| SELFHTML/Navigationshilfen XML/DTDs Darstellung von XML-Daten |
 |
XSLT-Elemente |
|
|
 | |
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.
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> |
<?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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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 < 10000"> <xsl:text> (eine kleine Zahl)</xsl:text> </xsl:when> <xsl:otherwise> <xsl:text> (eine große Zahl)</xsl:text> </xsl:otherwise> </xsl:choose> </div> </xsl:template> </xsl:stylesheet> |
In den XML-Daten des Beispiels werden eine Reihe Zahlen notiert, und zwar jeweils in einem Element namens zahl. Im Beispiel-Stylesheet wird mit <xsl:template match="zahl"> das Template definiert, das die HTML-Ausgabe der Zahlen steuert. Mit <xsl:value-of select="." /> wird der Wert der Zahl ausgegeben (siehe auch xsl:value-of). Anschließend wird eine Variable namens wert definiert, die sich den Wert, also den Inhalt zwischen <zahl> und </zahl>, merkt (siehe auch xsl:variable). Mit <xsl:choose> wird sodann eine Abfragereihe eingeleitet. Sie enthält eine xsl:when-Abfrage und eine xsl:otherwise-Anweisung. Bei der xsl:when-Abfrage wird abgefragt, ob der Wert der Variablen wert kleiner als 10000 ist. Wenn ja, wird hinter die bereits ausgegebene Zahl der Text (eine kleine Zahl) ausgegeben, andernfalls der Text (eine große Zahl). Für die Textausgabe wird xsl:text benutzt.
|
|
xsl:comment (Kommentar setzen)Schließt Ausgaben im Ergebnisbaum in XML- (auch HTML)-gerechte Kommentare ein, sodass der Inhalt nicht ausgegeben wird.
Hat keine Attribute.
Kann innerhalb von xsl:template vorkommen.
<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>
|
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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>
|
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.
<?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> |
<?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> |
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.
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> |
<?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>
|
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-eacheine 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.
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> |
<?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 >= 200">
<tr>
<xsl:apply-templates />
</tr>
</xsl:if>
</xsl:template>
<xsl:template match="name">
<td><xsl:value-of select="." /></td>
</xsl:template>
<xsl:template match="punkte">
<td><xsl:value-of select="." /></td>
</xsl:template>
</xsl:stylesheet>
|
Die XML-Daten im Beispiel enthalten Spielergebnisse, und zwar mit Spielernamen und erreichten Punkten. Im Beispiel-Stylesheet wird daraus eine HTML-Tabelle erzeugt. Es sollen jedoch nur Spieler in der Tabelle erscheinen, die 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 >= 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.
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.
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> |
<?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>
|
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.
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> |
<?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>
|
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> |
text { font-size:21px; color:blue; }
|
Das XSLT-Stylesheet erzeugt eine neue XML-Datei, in die alle Daten der Input-Datei, im Beispiel also von processing_instruction.xml kopiert werden. Dazu dient einerseits die xsl:output-Anweisung, mit der die XML-Deklaration für die neue XML-Datei erzeugt wird, und andererseits das Kopieren der text-Elemente mit Hilfe von xsl:copy-of in den Ergebnisbaum, also die neue XML-Datei. Der Unterschied der neu erzeugten XML-Datei zur alten ist, dass sie eine Verarbeitungsanweisung zum Einbinden eines 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.
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> |
<?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> |
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.
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> |
<?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> |
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. |
|
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> |
<?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> |
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.
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> |
<?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> |
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.
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> |
<?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> <!-- document.write("<p>" + document.lastModified + "</p>"); //--> </xsl:text> </script> </xsl:template> </xsl:stylesheet> |
Die XML-Daten des Beispiels enthalten eine Behauptung. Im Beispiel-Stylesheet wird die Behauptung in einen HTML-Absatz übersetzt. Unterhalb davon ist jedoch noch eine xsl:text-Anweisung zum Erzeugen von weiterem Text notiert. Diese wiederum enthält die HTML-gerechte Notation eines kleinen JavaScripts, das in einem Textabsatz den Zeitpunkt der letzten Änderung der Datei ausgibt. So, wie die Anweisung im Beispiel notiert ist, müssen innerhalb davon die XML-eigenen Zeichen maskiert werden.
|
|
xsl:transform (Stylesheet Wurzelelement)Ist ein Synonym für xsl:stylesheet.
|
|
xsl:value-of (Wert ausgeben)Erzeugt eine gespeicherte Zeichenkette an der aktuellen Position im Ausgabebaum. Bei der gespeicherten Zeichenkette kann es sich z.B. um den Inhalt eines Knotens der XML-Daten handeln, oder um den Inhalt einer zuvor definierten Variablen.
Hat folgende Attribute:
disable-output-escaping= |
(optional) bestimmt, wie bei der Ausgabe XML-eigene Zeichen wie < oder > behandelt werden. Mögliche Werte sind yes und no (Voreinstellung). Bei yes werden solche Zeichen nicht in ihre benannten Namen umgewandelt, bei no werden sie umgewandelt. |
extension-element-prefixes= |
(optional) gibt Namensräume an, die benötigt werden, um Elemente dieser anderen Namensräume zu erkennen. Erlaubt sind eine oder mehrere Angaben. Mehrere Angaben sind durch Leerzeichen zu trennen. |
select= |
(obligatorisch) Wählt einen Knoten oder eine Variable oder einen Parameter aus, dessen Inhalt verwendet werden soll. |
Kann innerhalb von xsl:template vorkommen.
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> |
<?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> |
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.
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> |
<?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> |
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:choosevorkommen.
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.
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> |
<?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 <= number(/test/ende)">
<tr>
<td><xsl:value-of select="$Zaehler" /></td>
<td><xsl:value-of select="$Zaehler * $Zaehler" /></td>
</tr>
<xsl:call-template name="Schleife">
<xsl:with-param name="Zaehler" select="$Zaehler + 1" />
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="Abbruch" />
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="Abbruch">
<xsl:comment>Schleife beendet!</xsl:comment>
</xsl:template>
</xsl:stylesheet>
|
Die XML-Daten im Beispiel definieren einfach eine kleinere und eine größere Zahl, von denen die erste einen Startwert darstellt und die zweite einen Endwert. Im Beispiel-Stylesheet wird aus diesen Zahlen eine HTML-Tabelle erzeugt, die für alle Zahlen zwischen dem Startwert und dem Endwert in je einer Tabellenzeile die aktuelle Zahl und deren Quadrat ausgibt. Dazu wird innerhalb der Template-Definition für das Wurzelelement mit xsl:call-template eine andere Template-Definition namens Schleife aufgerufen. Innerhalb dieser xsl:call-template-Anweisung ist eine xsl:with-param-Anweisung notiert, die einem Parameter namens Zaehler mit select= einen Wert zuweist. In dem Fall ist das der Inhalt des Elements start (Pfad: /test/start). Dabei wird mit Hilfe der Funktion number() sichergestellt, dass der Inhalt des Elements als Zahl interpretiert wird.
In der aufgerufenen Template-Definition Schleife wird mit <xsl:param name="Zaehler" /> der Parameter namens Zaehler definiert. Nur so ist es der Template-Definition 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
|
| SELFHTML/Navigationshilfen XML/DTDs Darstellung von XML-Daten |
© 2001 
selfhtml@teamone.de