XML/XSL/XPath/Funktionen
Funktionen in XPath haben die Aufgabe, die Übersetzung der XML-Ausgangsdaten in den Ergebnisbaum (zum Beispiel nach HTML) genauer zu kontrollieren und dabei zusätzliche Features zur Verfügung zu stellen. Sie sind für den Einsatz innerhalb von XSLT-Stylesheets gedacht. Die einzelnen XPath-Funktionen erfüllen einen bestimmten Zweck (zum Beispiel das Extrahieren einer Teilzeichenkette aus einer Zeichenkette) und liefern im Normalfall einen Wert zurück (zum Beispiel die extrahierte Teilzeichenkette).
Die Funktionen bestehen aus einem Funktionsnamen, gefolgt von runden Klammern, in denen so genannte Argumente stehen können. Argumente werden benötigt, damit eine Funktion ihre Aufgabe erfüllen kann. So muss beispielsweise der Funktion, die aus einer Zeichenkette eine Teilzeichenkette extrahiert, mitgeteilt werden, aus welcher Zeichenkette sie welchen Teil extrahieren soll.
Bei der Beschreibung der Funktionen in diesem Abschnitt wird für jede Funktion beschrieben, ob sie Argumente erwartet, und wenn ja, welche. Wenn mehrere Argumente erforderlich sind, werden die einzelnen Argumente durch Komma getrennt. Wird als Argument eine Zeichenkette notiert, muss diese in Anführungszeichen stehen. Da XPath-Funktionen jedoch meistens innerhalb von Wertzuweisungen an Attribute von XSLT-Elementen vorkommen, die selbst schon in Anführungszeichen stehen, müssen Sie andere Anführungszeichen benutzen. Wenn die Wertzuweisung an das XSLT-Element beispielsweise in doppelten Anführungszeichen steht, muss eine Zeichenkette, die innerhalb davon einer XPath-Funktion übergeben wird, in einfachen Anführungszeichen (Hochkommata) stehen, also z. B. so: <xsl:value-of select="document('datei2.xml')" />. Zahlen und Namen von Elementen der XML-Daten können dagegen ohne Anführungszeichen übergeben werden.
Da die Funktionen einen Wert zurückgeben, werden sie innerhalb von XSLT normalerweise an den Stellen verwendet, wo Attribute Wertzuweisungen erhalten. So könnte beispielsweise das XSLT-Element value-of in der folgenden Form notiert werden:
<xsl:value-of select="last()" />
Dabei wird also dem select-Attribut ein Wert zugewiesen, allerdings kein fester Wert, sondern ein dynamisch ermittelter. In diesem Fall wird er von der Funktion last() ermittelt.
Generell besteht keine Gewähr, dass jeder XSL-Prozessor, also die XSL interpretierende Software, alle die hier aufgelisteten und zum Standard gehörenden XPath-Funktionen kennt oder in vollem Umfang verarbeitet.
Bei den Beschreibungen der Funktionen 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.
Inhaltsverzeichnis
- 1 boolean() (Argument als wahr oder falsch bewerten)
- 2 ceiling() (Zahl aufrunden)
- 3 concat() (Zeichenketten zu einer zusammenfassen)
- 4 contains() (auf bestimmte Teilzeichenkette überprüfen)
- 5 count() (Anzahl Knoten in einem Knoten-Set ermitteln)
- 6 current() (aktuellen Knoten ermitteln)
- 7 document() (anderes XML-Dokument aufrufen)
- 8 element-available() (Verfügbarkeit eines XSLT-Elements überprüfen)
- 9 false() (booleschen Wert für "falsch" erzeugen)
- 10 floor() (Zahl abrunden)
- 11 format-number() (Zahl in Zeichenkette umwandeln)
- 12 function-available() (Verfügbarkeit einer XPath-Funktion überprüfen)
- 13 generate-id() (eindeutigen Bezeichner für ein Element generieren)
- 14 id() (Element mit bestimmtem Bezeichner auswählen)
- 15 key() (Elemente mit Hilfe eines Schlüsselwerts auswählen)
- 16 lang() (Element auf bestimmten Sprachcode überprüfen)
- 17 last() (Positionsnummer des letzten Knotens einer Reihe ermitteln)
- 18 local-name() (lokalen Namen eines Knoten-Sets ermitteln)
- 19 name() (Namen eines Knoten-Sets ermitteln)
- 20 namespace-uri() (Namensraum eines Elements ermitteln)
- 21 normalize-space() (Leerzeichen am Anfang und Ende einer Zeichenkette entfernen)
- 22 not() (Argument verneinen)
- 23 number() (Argument in eine Zahl umwandeln)
- 24 position() (Positionsnummer des aktuellen Knotens ermitteln)
- 25 round() (kaufmännisch auf- oder abrunden)
- 26 starts-with() (Überprüfen, ob Zeichenkette mit bestimmter Teilzeichenkette beginnt)
- 27 string() (Argument in Zeichenkette umwandeln)
- 28 string-length() (Anzahl Zeichen einer Zeichenkette ermitteln)
- 29 substring() (Teilzeichenkette aus Zeichenkette extrahieren)
- 30 substring-after() (Zeichenkette ab einer Position mit Teilzeichenkette ermitteln)
- 31 substring-before() (Zeichenkette vor einer Position mit Teilzeichenkette ermitteln)
- 32 sum() (Summe von Zahlenwerten ermitteln)
- 33 system-property() (Systemeigenschaften ermitteln)
- 34 translate() (Suchen und Ersetzen von Zeichen in einer Zeichenkette)
- 35 true() (booleschen Wert für "wahr" erzeugen)
- 36 unparsed-entity-uri() (ungeparste Einträge der DTD ermitteln)
- 37 Referenz
boolean() (Argument als wahr oder falsch bewerten)
Ermittelt, ob ein Ausdruck wahr oder falsch ist.
Erwartet folgende Argumente:
[Ausdruck]: irgendein mit XSL realisierbarer Ausdruck, der sich als wahr oder falsch bewerten lässt. Es kann sich z. B. um eine Vergleichsoperation handeln, aber auch um den Test auf Vorhandensein eines Knotens.
Liefert true (wahr) oder false (falsch) zurück.
<xsl:template match="name">
<xsl:choose>
<xsl:when test="boolean(vorname) != boolean(nachname)">
<xsl:message>Es müssen entweder Vor- und Nachname,
oder überhaupt kein Name angegeben werden!</xsl:message>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="vorname">
<xsl:apply-templates select="nachname">
</xsl:otherwise>
</xsl:choose>
</xsl:template>
Im Beispiel wird ein Template für ein XML-Element namens name definiert. Es wird angenommen, dass dieses Element zwei untergeordnete Elemente vorname und nachname enthalten muss. Im Beispiel-Stylesheet wird mit
<xsl:when test="boolean(vorname) != boolean(nachname)">
abgefragt, ob tatsächlich beide untergeordneten Elemente vorhanden sind. Ist das nicht der Fall, wird eine entsprechende Meldung ausgegeben. Andernfalls wird der xsl:otherwise-Zweig ausgeführt, der die Templates zum Übersetzen der Unterelemente aufruft.
ceiling() (Zahl aufrunden)
Rundet eine Bruchzahl zur nächsthöheren Ganzzahl auf. Die Zahl 5.7234 wird auf 6 aufgerundet, aber 0.00001 wird auch auf 1 aufgerundet. Wichtig ist, dass "Kommazahlen" den Punkt als Dezimalzeichen haben. Andernfalls werden sie als ungültige Zahlen (NaN – not a number) interpretiert.
Erwartet folgende Argumente:
[Zahl]: Die aufzurundende Zahl. Es kann sich auch um den Inhalt eines Knotens oder den einer Variablen handeln. Dabei wird der Wert intern zunächst als Zahl umgewandelt, und zwar so, als würde die Funktion number() angewendet.
Liefert die nächsthöhere Ganzzahl zurück.
<xsl:value-of select="ceiling(betrag)" /><xsl:text>.-</xsl:text>
Im Beispiel wird von einem XML-Element namens betrag angenommen, dass es einen "krummen" Wert enthält, der auf den nächsthöheren Euro-Ganzzahlwert aufgerundet werden soll. Dazu wird beim Auswählen des Inhalts von betrag mit xsl:value-of im select-Attribut die Funktion ceiling() aufgerufen. Sie bewirkt, dass der Elementinhalt aufgerundet wird, bevor er in den Ergebnisbaum der Datenausgabe übernommen wird.
concat() (Zeichenketten zu einer zusammenfassen)
Hängt mehrere Zeichenketten aneinander.
Erwartet folgende Argumente:
[Zeichenkette], [Zeichenkette], ...: Hängt alle Zeichenkette in der angegebenen Reihenfolge aneinander. Es kann sich direkt um Text handeln, aber auch um den Inhalt eines Knotens oder den Wert einer Variablen. Die Zeichenketten werden durch Kommata getrennt.
Liefert die zusammengesetzte Zeichenkette zurück.
<xsl:value-of select="concat(vorname, ' heißt mit Zuname ', zuname)"/>
Im Beispiel wird angenommen, dass es zwei verfügbare XML-Elemente vorname und zuname gibt. Bei der Übersetzung in den Ergebnisbaum soll daraus ein Satz vom Typ Heidi heißt mit Zuname Finkenzeller erzeugt werden. Dazu wird beim Auswählen des Inhalts mit xsl:value-of im select-Attribut die Funktion concat() angewendet. Sie bekommt drei Zeichenketten übergeben: den Inhalt des Elements vorname, die feste Zeichenkette heißt mit Zuname, und den Inhalt des Elements zuname.
contains() (auf bestimmte Teilzeichenkette überprüfen)
Überprüft, ob in einer Zeichenkette eine bestimmte Teilzeichenkette vorhanden ist.
Erwartet folgende Argumente:
- [Zeichenkette]: Die Zeichenkette, in der überprüft werden soll.
- [Teilzeichenkette]: Die Teilzeichenkette, auf die hin die Zeichenkette überprüft werden soll.
Liefert true zurück, wenn die Teilzeichenkette vorhanden ist, und false, wenn sie nicht vorhanden ist.
<xsl:if test="contains(zuname, 'A')">
<xsl:value-of select="zuname" />
</xsl:if>
Im Beispiel wird mit xsl:if geprüft, ob der Wert eines XML-Elements zuname ein großes A enthält. Wenn ja, wird der Inhalt des Elements ausgegeben. Dazu wird im test-Attribut der xsl:if-Anweisung mit contains(zuname, 'A') in der Zeichenkette, die das Element zuname speichert, nach der Teilzeichenkette A gesucht. Auf diese Weise könnten also beispielsweise nur Zunamen in den Ergebnisbaum einfließen, die mit A beginnen.
count() (Anzahl Knoten in einem Knoten-Set ermitteln)
Ermittelt, wieviele Knoten auf der Ebene unterhalb eines Knoten-Sets enthalten sind.
Erwartet folgende Argumente:
- [Knoten-Set]: Ein Knoten-Set bzw. einen Pfad nach XPath-Syntax, für das die Anzahl der darin enthaltenen Knoten der nächstunteren Ebene bestimmt werden soll.
Liefert die Anzahl der untergeordneten Knoten zurück.
<xsl:variable name="anzahl" select="count(//listeneintrag)" />
...
<xsl:template match="liste">
<xsl:for-each select="listeneintrag">
<p>
<xsl:value-of select="position()" />
<xsl:text>. von </xsl:text>
<xsl:value-of select="$anzahl" />
<xsl:text>: </xsl:text>
<xsl:value-of select="." />
</p>
</xsl:for-each>
</xsl:template>
Das Beispiel nimmt an, dass es ein XML-Element namens liste gibt, das aus mehreren Unterelementen listeneintrag besteht. Zunächst wird mit xsl:variable eine Variable namens anzahl definiert, in der die Anzahl der Listeneinträge gespeichert wird. Dazu wird im select-Attribut die Funktion count() angewendet. Als Argument wird ihr das Element listeneintrag übergeben. In der for-each-Schleife, die alle Listeneinträge abarbeitet, wird vor dem Text des Listeneintrags jeweils die aktuelle Positionsnummer mit position() ausgegeben, und dahinter die Gesamtzahl, die in der Variablen anzahl gespeichert ist, also etwa so:
- 1. von 5: Text des ersten Listeneintrags
- 2. von 5: Text des zweiten Listeneintrags
current() (aktuellen Knoten ermitteln)
Stellt den Bezug zum jeweils aktuellen Knoten her.
Erwartet keine Argumente.
Liefert das Knoten-Set zurück, das den aktuellen Knoten enthält.
<xsl:value-of select="current()" />
Die Anweisung im Beispiel drückt das gleiche aus wie die üblichere Anweisung:
<xsl:value-of select="." />
document() (anderes XML-Dokument aufrufen)
Erlaubt es, XML-Ausgangsdaten aus anderen XML-Dateien als der, in der das Stylesheet eingebunden ist, mit in den Ergebnisbaum zu übernehmen.
Erwartet folgende Argumente:
- [URI]: Angabe einer XML-Datei, die mit eingebunden werden soll. Es kann sich um eine relative Adressierung handeln oder um eine absolute Angabe, z. B.
http://....Wird keine andere XML-Datei angegeben, sondern ein Element mit XPath-Syntax adressiert, so wird das Element und gegebenenfalls sein untergeordneter Elementenbaum an dieser Stelle eingebunden. - [Knoten-Set]: (optional) Angabe der Basis innerhalb der eingebundenen Daten, auf das sich relative XPath-Adressierungen beziehen können. Gemeint ist der erste Knoten des Knoten-Sets.
Liefert die ermittelte Elementstruktur der anderen XML-Datei oder des angegebenen Elements ab dem Wurzelelement zurück.
<xsl:template match="beispiel">
<pre>
<xsl:value-of select="document(./@quelle)" />
</pre>
</xsl:template>
Im Beispiel wird angenommen, dass es ein XML-Element namens beispiel gibt, dass in einem Attribut eine Quellenangabe zu einer XML-Datei enthält, z. B.:
<beispiel quelle="../quellen/beispiel03.xml" />.
Im Stylesheet wird für die HTML-Ausgabe dieses Elements mit <pre>...</pre> ein Bereich mit präformatiertem Text definiert. Darin wird mit xsl:value-of der Inhalt der Datei ausgegeben, die im Attribut quelle angegeben ist. Um auf die Datei zuzugreifen, wird im select-Attribut die document()-Funktion angewendet. Als Argument wird ihr die Angabe zum Attribut quelle übergeben.
element-available() (Verfügbarkeit eines XSLT-Elements überprüfen)
Ermittelt, ob ein XSLT-Element im verwendeten XSLT-Parser verfügbar ist oder nicht. Dient daher als Maßnahme zur Vermeidung von Fehlern.
Erwartet folgende Argumente:
- [Elementname]: Name eines XSLT-Elements, dessen Verfügbarkeit überprüft werden soll.
Liefert true zurück, wenn das Element verfügbar ist, und false, wenn es nicht verfügbar ist.
<xsl:if test="element-available('xsl:number')">
<xsl:number level="single" count="eintrag" format="1. " />
</xsl:if>
Das Beispiel überprüft mit Hilfe der xsl:if-Anweisung, ob das XSLT-Element xsl:number verfügbar ist. Wenn ja, wird es innerhalb der xsl:if-Anweisung angewendet. Wenn nicht, wird zumindest ein Fehler vermieden.
false() (booleschen Wert für "falsch" erzeugen)
Verneint einen Ausdruck.
Erwartet keine Argumente
Liefert einfach den logischen Wert false zurück.
<xsl:variable name="passwortanzeige" select="false()"/>
<xsl:template name="passwort">
<xsl:choose>
<xsl:when test="$passwortanzeige">
<xsl:value-of select="." />
</xsl:when>
<xsl:otherwise>
<xsl:text>[Passwort]</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
Im Beispiel wird mit xsl:variable eine Variable namens passwortanzeige definiert, deren Wert auf den logischen Wert false gesetzt wird. Verantwortlich dafür ist der Einsatz der Funktion false(), die einfach dem select-Attribut zugewiesen wird und dadurch für das Setzen des Wertes sorgt. Weiterhin zeigt das Beispiel eine Template-Definition für ein Element namens passwort. Innerhalb dieser Template-Definition wird in einer xsl:choose-Konstruktion abgefragt, wie es mit der Passwortanzeige steht. Wenn die Variable $passwortanzeige wahr ist, wird mit <xsl:value-of select="." /> der Wert des passwort-Elements ausgegeben. Andernfalls wird nur die Zeichenkette [Passwort] ausgegeben.
floor() (Zahl abrunden)
Rundet eine Bruchzahl zur basierenden Ganzzahl ab. Die Zahl 5.7234 wird auf 5 abgerundet, und 5.99997 wird auch zu 5 abgerundet. Wichtig ist, dass "Kommazahlen" den Punkt als Dezimalzeichen haben. Andernfalls werden sie als ungültige Zahlen (NaN – not a number) interpretiert.
Erwartet folgende Argumente:
- [Zahl]: Die abzurundende Zahl. Es kann sich auch um den Inhalt eines Knotens oder den Wert einer Variablen handeln. Dabei wird der Wert intern zunächst als Zahl umgewandelt, und zwar so, als würde die Funktion number() angewendet.
Liefert die basierende Ganzzahl zurück.
<xsl:template match="zahl">
<div style="background-color:yellow"><xsl:value-of select="floor(./@wert)" /></div>
</xsl:template>
Das Beispiel nimmt ein XML-Element namens zahl an, das z. B. folgende Ausprägung haben könnte:
<zahl wert="63,47" />. In der Template-Definition zur HTML-Ausgabe dieses Elements wird auf das Attribut mit
@wert zugegriffen. Dabei wird dieser Attributzugriff jedoch in die Funktion floor() eingebettet, sodass im Falle einer Zahl mit dem Wert 63,47 nur 63 in der HTML-Ausgabe erscheint.
format-number() (Zahl in Zeichenkette umwandeln)
Wandelt eine Zahl in eine Zeichenkette um und erlaubt es, die Formatierung der umgewandelten Zahl zu beeinflussen.
Erwartet folgende Argumente:
- [Zahl]: Der umzuwandelnde Wert. Es kann sich auch um den Inhalt eines Elements oder den Wert einer Variablen handeln. Dabei wird der Wert intern zunächst als Zahl umgewandelt, und zwar so, als würde die Funktion number() angewendet.
- [Formatregel]: Eine Darstellungs-Syntax für die Formatierung der umgewandelten Zahl. Die Syntax der Formatregel orientiert sich dabei an dem Schema, das in Java 1.1 für die decimal_format-Klasse implementiert ist. Allerdings gibt es keine zwingende Korrelation zwischen der XPath-Syntax und der Java-Implementierung. Folgende Zeichen sind üblich:
- 0 = eine Ziffer
- # = eine Ziffer, 0 wird jedoch nicht angezeigt
- . = Platzhalter für Dezimalpunkt-Trennzeichen
- , = Platzhalter für ein Gruppierungs-Trennzeichen, z. B. für Tausender
- ; = zum Trennen von mehreren Formaten
- - = negatives Vorzeichen als Voreinstellung
- % = Wert mit 100 multiplizieren und als Prozentwert anzeigen
- ? = Wert mit 1000 multiplizieren und als Promillewert anzeigen
- ¤ = Währungssymbol, wird durch das voreingestellte Währungssymbol ersetzt (noch nicht in Java 1.1!).
- ' = zum Maskieren von format-bedeutenden Zeichen wie 0, #, . usw.
- [Name]: (optional) Name eines Formats, das mit Seite xsl:decimal-format definiert wird.
Liefert eine Zeichenkette mit der formatierten Zahl zurück.
<xsl:template match="wert">
<xsl:value-of select="format-number(.,'##0.0%')" />
</xsl:template>
Das Beispiel nimmt ein XML-Element namens wert an, für dessen Ausgabe in den HTML-Ergebnisbaum ein Template definiert wird. Dabei wird der Inhalt des Elements wert, angesprochen durch die Funktion current() als erstes Argument der Funktion format-number() übergeben. Für die Formatierung wird bestimmt, dass es eine bis zu dreistellige Zahl mit einer Nachkommastelle sein kann, die als Prozentwert ausgegeben wird. Durch die Zuweisung dieses Konstrukts an das select-Attribut von xsl:value-of wird bewirkt, dass der Inhalt von wert entsprechend der Formatregel ausgegeben wird.
function-available() (Verfügbarkeit einer XPath-Funktion überprüfen)
Ermittelt, ob eine XPath-Funktion im verwendeten XSLT-Parser verfügbar ist oder nicht. Dient daher als Maßnahme zur Vermeidung von Fehlern.
Erwartet folgende Argumente:
- [Funktionsname]: Name einer XPath-Funktion, deren Verfügbarkeit überprüft werden soll.
Liefert true zurück, wenn die Funktion verfügbar ist, und false, wenn sie nicht verfügbar ist.
<xsl:choose>
<xsl:when test="function-available('normalize-space')">
<xsl:value-of select="normalize-space(.)" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="." />
</xsl:otherwise>
</xsl:choose>
Das Beispiel überprüft mit Hilfe einer xsl:choose-Konstruktion, ob die XPath-Funktion normalize-space() verfügbar ist. Wenn ja, wird sie innerhalb der xsl:value-of-Anweisung angewendet, um bei der Ausgabe des aktuellen Elements, das mit . angegeben wird, alle überflüssigen Leerraumzeichen am Anfang und am Ende zu entfernen. Andernfalls, wenn die Funktion nicht verfügbar ist, wird der Inhalt des aktuellen Elements ohne weitere Vorbehandlung ausgegeben.
generate-id() (eindeutigen Bezeichner für ein Element generieren)
Erzeugt im Ergebnisbaum automatisch einen eindeutigen Bezeichner. Der Bezeichner muss nicht bei jedem Generierungsvorgang der gleiche sein (könnte also zum Beispiel durch zeitabhängige Algorithmen erzeugt sein), aber er ist in jedem Fall innerhalb des einzelnen Dokuments eindeutig. Der generierte Bezeichner entspricht in jedem Fall den Konventionen für Bezeichner in XML.
Erwartet folgende Argumente:
- [Knoten-Set]: (optional) Knoten-Set bzw. einen Pfad nach XPath-Syntax, der eine ID erhalten soll.
Liefert eine Zeichenkette mit dem generierten Bezeichner zurück.
<xsl:template match="absatz">
<p><a id="{generate-id(.)}">
<xsl:value-of select="." />
</a></p>
</xsl:template>
absatz. Jedes dieser Elemente erhält bei der Übersetzung in ein HTML-Konstrukt einen Anker, definiert mit <a id=>...</a>. Der Wert, der jeweils beim Attribut
id vergeben wird, wird automatisch erzeugt, und zwar durch Anwendung der Funktion generate-id(). Als Argument wird das aktuelle Element (.) übergeben. Die geschweiften Klammern stellen ein Attributwert-Template dar, das den Einsatz von XPath-Ausdrücken beim Erstellen von Attributen ermöglicht.
<xsl:if test="a = b">prüft nur, ob a und b den gleichen Inhalt haben.
<xsl:if test="generate-id(a) = generate-id(b)">prüft dagegen, ob es wahr ist, dass beide Knoten identisch sind.
id() (Element mit bestimmtem Bezeichner auswählen)
Wählt ein Element aufgrund einer ID aus. Dazu muss das Element ein Attribut mit Identifikationswert besitzen, das in der zugehörigen DTD entsprechend definiert sein muss. Da die Wertzuweisungen an solche Attribute dokumentweit eindeutig sein müssen, eignen sie sich hervorragend, um das Element auszuwählen.
Erwartet folgende Argumente:
- [ID-Wert]: Der ID-Wert desjenigen Elements, das ausgewählt werden soll.
Liefert das Element oder mehrere Elemente zurück, deren ID-Wert ausgewählt wurde.
<xsl:template match="name">
<li><xsl:value-of select="id('p01')" /><xsl:value-of select="." /></li>
</xsl:template>
Das Beispiel definiert ein Template für ein Element namens name. Darin wird in einem HTML Aufzählungspunkt ein fixes Label (denkbar wäre z. B. ein Wert wie Name, Vorname: ) und dahinter der aktuelle Wert des Elements name mit <xsl:value-of select="." /> ausgegeben. Der Wert des Labels wird ebenfalls mit einer xsl:value-of-Anweisung ermittelt. Dabei ist im select-Attribut die Funktion id() notiert, die auf ein Element mit dem Identifikationswert p01 zugreift. Dieses Element könnte in den XML-Daten beispielsweise so notiert sein:
<prefix x="p01">Name, Vorname: </prefix>
Dabei wäre das Attribut x in der zugehörigen DTD als Attribut mit Identifikationswert definiert.
key() (Elemente mit Hilfe eines Schlüsselwerts auswählen)
Wählt einen Knoten aus, der für einen benannten Schlüssel einen bestimmten Wert besitzt. Sinnvoll, um etwa von allen Elementen nur solche auszuwählen, die aufgrund von Inhalt oder Wertzuweisungen an Attribute bestimmte Kriterien erfüllen.
Erwartet folgende Argumente:
- [Name]: Name eines Schlüssels. Der Schlüssel selbst muss zuvor mit Hilfe der Seite xsl:key-Anweisung definiert worden sein und im name-Attribut der Anweisung den hier angegebenen Namen erhalten haben.
- [Wert]: Der Wert, der zur Eingrenzung auszuwählender Elemente dient. Nur Elemente, die dem Schlüssel entsprechen und dabei diesen Wert besitzen, werden ausgewählt.
Liefert das erste Element zurück, das den Auswahlkriterien entspricht.
<xsl:key name="k3" match="datensatz" use="handelsklasse" />
<xsl:template match="/">
<html><head><body>
<xsl:for-each select="key('k3','III')">
<xsl:apply-templates />
</xsl:for-each>
</body></html>
</xsl:template>
Im Beispiel wird mit Hilfe der xsl:key-Anweisung für ein Element namens datensatz ein Schlüssel definiert, der den Namen k3 erhält und sich auf den Inhalt eines zu datensatz untergeordneten Elements namens handelsklasse bezieht. Es wird angenommen, dass die XML-Daten unterhalb ihres Wurzelelements aus vielen Elementen vom Typ datensatz bestehen. Durch Anwendung der xsl:for-each-Anweisung in Verbindung mit der Funktion key() im select-Attribut werden nur solche Datensätze ausgewählt, die im untergeordneten Element handelsklasse den Wert III enthalten. Für diesen Fall werden mit xsl:apply-templates untergeordnete Template-Definitionen aufgerufen.
lang() (Element auf bestimmten Sprachcode überprüfen)
Überprüft, ob ein Element einen bestimmten Sprachcode verwendet. Voraussetzung ist, dass in dem Element das XML-Attribut xml:lang notiert ist, also beispielsweise:
<description xml:lang="de">die Beschreibung zu irgendetwas</description>
In der DTD wäre folgende zugehörige Definition erforderlich:
<!ATTLIST description xml:lang NMTOKEN #IMPLIED>
Die Angaben zum Attribut xml:lang können Sprachkürzel sein.
Erwartet folgende Argumente:
[Zeichenkette]für den Ländercode, auf den hin überprüft werden soll (z. B. de).
Liefert true zurück, wenn das Element diesen Ländercode in seinem xml:lang-Attribut angibt, und false, wenn kein xml:lang-Attribut vorhanden ist, oder wenn es einen anderen als den im Argument übergebenen Wert hat.
<xsl:template match="description">
<xsl:choose>
<xsl:when test="lang('de')">
<h4><xsl:text>Beschreibung:</xsl:text></h4>
</xsl:when>
<xsl:otherwise>
<h4><xsl:text>Description:</xsl:text></h4>
</xsl:otherwise>
<p><xsl:value-of select="." /></p>
</xsl:choose>
</xsl:template>
Das Beispiel sorgt dafür, dass einem Element namens description im HTML-Ergebnisbaum eine h4-Überschrift vorangestellt wird. Dabei wird mit Hilfe der xsl:choose-Anweisung im when-Zweig mit Hilfe der Funktion lang() überprüft, ob das description-Element xml:lang="de" als Attribut enthält. Wenn ja, wird als Text der h4-Überschrift das deutsche Wort Beschreibung ausgegeben, andernfalls das englische Wort Description. Am Ende wird dann noch mit xsl:value-of der Inhalt des description-Elements ausgegeben.
last() (Positionsnummer des letzten Knotens einer Reihe ermitteln)
Ermittelt die Positionsnummer des letzten von mehreren Knoten eines Knoten-Sets.
Erwartet keine Argumente.
Liefert die Positionsnummer des letzten Knotens zurück.
<xsl:template match="zahl">
<xsl:value-of select="." />
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
Das Beispiel definiert ein Template für ein Element namens zahl. Im Beispiel wird angenommen, dass mehrere solcher Elemente nacheinander innerhalb eines gemeinsamen übergeordneten Elements notiert sind, also beispielsweise die einzelnen Zahlen innerhalb einer Lottozahlenreihe. Bei jeder Anwendung des Templates wird zunächst mit xsl:value-of die aktuelle Zahl ausgegeben. Danach soll hinter allen außer der letzten Zahl ein Komma ausgegeben werden, sodass eine Ausgabe wie z. B. 3,15,28,29,33,43 entsteht. Dazu wird mit xsl:if abgefragt, ob die Positionsnummer des aktuellen Elements innerhalb der Reihe (ermittelt mit position()) ungleich (!=) der Positionsnummer des letzten Elements (ermittelt mit der last()-Funktion) ist. Ist dies der Fall, wird ein Komma ausgegeben.
local-name() (lokalen Namen eines Knoten-Sets ermitteln)
Ermittelt aus einem Knotennamen mit Namensraumangabe den lokalen Namensteil – aus einem Elementnamen wie xhtml:blockquote würde also blockquote ermittelt.
Erwartet folgende Argumente:
- [Knoten-Set]: (optional) Ein Knoten-Set bzw. einen Pfad nach XPath-Syntax, dessen lokaler Name ermittelt werden soll. Fehlt die Angabe des Arguments, wird die Funktion auf das jeweils aktuelle Element angewendet.
Liefert den lokalen Elementnamen zurück, sofern der Elementname aus einer Namensraumangabe und dem lokalen Elementnamen besteht. Ansonsten wird eine leere Zeichenkette zurückgeliefert.
<xsl:template match="autor:*">
<div>
<p>Name des Knotens: <b><xsl:value-of select="name(.)" /></b></p>
<p>local-name:<b><xsl:value-of select="local-name(.)" /></b></p>
<p>Inhalt:<b><xsl:apply-templates /></b></p>
</div>
</xsl:template>
Der Beispielausschnitt zeigt eine Template-Definition für angenommene Elemente, die aus dem Namensraum autor stammen. In XML wären das beispielsweise Elemente, die in der Form <autor:vorname>...</autor:vorname> notiert sind. Das Template ermittelt mit name(.) den vollständigen Namen des aktuellen Knotens, also z. B. autor:vorname, und mit local-name(.) den lokalen Namensteil, also z. B. vorname. Anschließend werden mit xsl:apply-templates untergeordnete Template-Definitionen angewendet.
name() (Namen eines Knoten-Sets ermitteln)
Ermittelt den vollständigen Namen eines Knoten-Sets, gegebenenfalls auch mit XML-Namensraumangabe.
Erwartet folgende Argumente:
- [Knoten-Set]: (optional) Ein Knoten-Set bzw. einen Pfad nach Seite XPath-Syntax, dessen vollständiger Name ermittelt werden soll. Fehlt die Angabe des Arguments, wird die Funktion auf das jeweils aktuelle Element angewendet.
Liefert den Namen des ausgewählten Knoten-Sets zurück.
<xsl:template name="Kurzbeschreibung">
<b><xsl:value-of select="name()" /><xsl:text>: </xsl:text></b><xsl:value-of select="." />
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens Kurzbeschreibung. Darin wird definiert, dass zuerst der Name des Elements ausgegeben wird, also Kurzbeschreibung, dann ein Doppelpunkt, und dann der Inhalt des Elements. Die Ausgabe des Elementnamens wird erreicht durch die xsl:value-of-Anweisung, die im select-Attribut als Wert die Funktion name() zugewiesen bekommt.
namespace-uri() (Namensraum eines Elements ermitteln)
Ermittelt den URI für die DTD zum verwendeten XML-Namensraum. Es handelt sich normalerweise um jene Angaben, die bei der xsl:stylesheet-Anweisung im xmlns:-Attribut gemacht wurden. Voraussetzung dafür, dass ein Wert zurückgeliefert wird, ist, dass ein Element eine Namensraumangabe verwendet, also z. B. xsl:template oder xhtml:div.
Erwartet folgende Argumente:
- [Knoten-Set]: (optional) Ein Knoten-Set bzw. einen Pfad nach XPath-Syntax, dessen URI der DTD für den XSL-Namensraum ermittelt werden soll. Fehlt die Angabe des Arguments, wird die Funktion auf das jeweils aktuelle Element angewendet.
Liefert den URI zurück, die für den zugehörigen Namensraum des Elements zurückgegeben wurde.
<?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>
<b><xsl:text>XSL-URI dieses Stylesheets: </xsl:text></b>
<xsl:value-of select="namespace-uri(document('')/*)" />
</body></html>
</xsl:template>
</xsl:stylesheet>
Das Beispiel zeigt ein vollständiges XSLT-Stylesheet. Im einleitenden stylesheet-Tag wird wie üblich mit xmlns:xsl="http://www.w3.org/1999/XSL/Transform" der URI der DTD für den XSL-Namensraum angegeben. Im weiteren Verlauf des Stylesheets wird ein Template für das Wurzelelement definiert. Darin wird aber einfach nur der URI des XSL-Namensraums für dieses Stylesheet ausgegeben. Dazu wird bei der xsl:value-of-Anweisung im select-Attribut als Wert die Funktion namespace-uri() übergeben. Die Ausgabe im Beispiel würde lauten:
XSL-URI dieses Stylesheets: http://www.w3.org/1999/XSL/Transform
Im Beispiel wird der Funktion namespace-uri() als Argument document('')/* übergeben. Das ist folgendermaßen zu verstehen: es soll das Dokument-Element ermittelt werden, was am einfachsten durch die Funktion document() (mit dem Leerstring als Parameter) bewerkstelligt wird. Mit dem daran anschließenden /* wird, da sich der gesamte Ausdruck innerhalb eines Aufrufs von namespace-uri() befindet, der Namensraum-URI für alle Elemente innerhalb dieses Dokument-Elements ermittelt.
normalize-space() (Leerzeichen am Anfang und Ende einer Zeichenkette entfernen)
Entfernt am Anfang und am Ende der übergebenen Zeichenkette die Leerraumzeichen und ersetzt mehrere aufeinanderfolgende Leerraumzeichen in der Zeichenkette durch ein einziges Leerzeichen (#x20). Leerraumzeichen sind die Zeichen mit den Hexadezimalwerten #x20 (einfaches Leerzeichen), #x9 (Tabulator-Zeichen), #xD (Wagenrücklaufzeichen) und #xA (Zeilenvorschub-Zeichen).
Erwartet folgende Argumente:
- [Zeichenkette]: (optional) Die Zeichenkette, die behandelt werden soll. Fehlt das Argument, wird die Funktion auf den Inhaltsknoten des aktuellen Knotens angewendet, bei einem Element
<name>...</name>beispielsweise auf dessen Inhalt, also das, was hier durch die drei Pünktchen markiert ist.
Liefert die behandelte Zeichenkette wieder zurück.
<xsl:template match="augenfarbe">
<tr>
<td><xsl:text>Augenfarbe</xsl:text></td>
<td><xsl:value-of select="normalize-space()" /></td>
</tr>
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens augenfarbe. Darin wird eine HTML-Tabellenzeile konstruiert. In der ersten Spalte steht der fixe Text Augenfarbe, und in der zweiten Spalte wird der Wert des Elements ausgegeben. Dabei werden jedoch zuvor führende und abschließende Leerraumzeichen, die z. B. durch unachtsames Editieren oder Behandlung durch andere Programme entstanden sein könnten, entfernt. Um das zu erreichen, wird nicht einfach <xsl:value-of select="." /> notiert, sondern <xsl:value-of select="normalize-space()" />.
not() (Argument verneinen)
Verneint das übergebene Argument und liefert dessen gegenteiliges Ergebnis zurück.
Erwartet folgende Argumente:
- [Bedingung]: Es kann sich um eine Vergleichsoperation handeln, aber auch um eine andere Funktion, die als Rückgabewert entweder true oder false liefert.
Liefert true zurück, wenn die als Argument übergebene Bedingung false ergibt, und false, wenn die Bedingung true ergibt.
<xsl:template match="geburtsjahr">
<xsl:if test="not(. > '1980')">
<xsl:value-of select="." />
</xsl:if>
</xsl:template>
Das Beispiel zeigt die Template-Definition eines XML-Elements namens geburtsjahr. Das Geburtsjahr soll nur dann ausgegeben werden, wenn der aktuelle Wert nicht größer ist als 1980. Dazu wird mit Hilfe der xsl:if-Anweisung eine Bedingung formuliert. Im test-Attribut, das die Bedingung enthält, wird mit . > '1980' die Bedingung "aktueller Wert größer 1980" formuliert. Der gesamte Ausdruck wird jedoch der Funktion not() als Argument übergeben, sodass die Bedingung umgekehrt wird und lautet: "aktueller Wert nicht größer 1980". Dies ist übrigens das gleiche, wie wenn als Bedingung notiert würde: <xsl:if test=". <='1980')">.
number() (Argument in eine Zahl umwandeln)
Versucht, eine übergebene Zeichenkette als Zahl zu interpretieren und gibt die ermittelte Zahl zurück. Wenn beispielsweise "31" übergeben wird, wird 31 zurückgeliefert. Wird "xyz" übergeben, wird NaN (not a number) zurückgeliefert. Bei Übergabe von "3xy" wird 3 zurückgeliefert. Und bei Übergabe von booleschen Werten, also true oder false, wird 0 für false und 1 für true zurückgeliefert. Führende und abschließende Leerraumzeichen der übergebenen Zeichenkette werden ignoriert.
Erwartet folgende Argumente:
- [Zeichenkette bzw. Wert]: (optional) Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln, oder um den Rückgabewert einer anderen Funktion. Fehlt das Argument, wird die Funktion auf den aktuellen Knoteninhalt angewendet, z. B. auf den Inhalt eines Elements.
Liefert die ermittelte Zahl zurück.
<xsl:template match="preis">
<xsl:value-of select="number()" />
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens preis. Das Template gibt den Wert des Elements aus, jedoch wird dabei versucht, den Wert numerisch zu interpretieren. Dazu wird im select-Attribut der xsl:value-of-Anweisung die Funktion number() angewendet. Da number() kein Argument übergeben wird, bezieht sich die Funktion auf den Wert des aktuellen Elements preis.
position() (Positionsnummer des aktuellen Knotens ermitteln)
Ermittelt, der wievielte Knoten ein aktueller Knoten in einem Knoten-Set ist. Bei einem Element namens liste mit beispielsweise 7 untergeordneten Elementen namens listeneintrag hat das zweite dieser Elemente in Bezug auf liste die Positionsnummer 2.
Erwartet keine Argumente.
Liefert die Ordnungszahl des aktuellen Knotens zurück. Beim ersten Knoten 1, beim zweiten 2 usw.
<xsl:variable name="anzahl" select="count(//listeneintrag)" />
...
<xsl:template match="liste">
<xsl:for-each select="listeneintrag">
<p>
<xsl:value-of select="position()" />
<xsl:text>. von </xsl:text>
<xsl:value-of select="$anzahl" />
<xsl:text>: </xsl:text>
<xsl:value-of select="." />
</p>
</xsl:for-each>
</xsl:template>
Das Beispiel nimmt an, dass es ein XML-Element namens liste gibt, das aus mehreren Unterelementen listeneintrag besteht. Zunächst wird mit xsl:variable eine Variable namens anzahl definiert, in der die Anzahl der Listeneinträge gespeichert wird. Dazu wird im select-Attribut die Funktion count() angewendet. Als Argument wird ihr das Element listeneintrag übergeben. In der for-each-Schleife, die alle Listeneinträge abarbeitet, wird vor dem Text des Listeneintrags jeweils die aktuelle Positionsnummer mit position() ausgegeben, und dahinter die Gesamtzahl, die in der Variablen anzahl gespeichert ist, also etwa so:
- 1. von 5: Text des ersten Listeneintrags
- 2. von 5: Text des zweiten Listeneintrags
- <xsl:value-of select="listeneintrag[position()=1]" /> kann auch so notiert werden:
- <xsl:value-of select="listeneintrag[1]" />
- <xsl:value-of select="listeneintrag[position()=last()]" /> kann auch so notiert werden:
- <xsl:value-of select="listeneintrag[last()]" />
- <xsl:if test="position()=1"> ist etwas anderes als <xsl:if test="1">! Im ersten Fall wird geprüft, ob der aktuell bearbeitete Knoten der erste ist, im zweiten Fall wird geprüft, ob der aktuelle Kontext logisch gesehen wahr ist.
round() (kaufmännisch auf- oder abrunden)
Rundet eine Bruchzahl zur nächstgelegenen Ganzzahl auf. Bei Bruchwerten kleiner als [Wert],5 wird abgerundet, bei Bruchwerten größer gleich [Wert],5 aufgerundet. Die Zahl 5,49 wird also auf 5 abgerundet, und 5,5 auf 6 aufgerundet.
Erwartet folgende Argumente:
- [Zahl]: Die zu rundende Zahl. Es kann sich auch um den Inhalt eines Knotens oder den einer Variablen handeln. Dabei wird der Wert intern zunächst als Zahl umgewandelt, und zwar so, als würde die Funktion number() angewendet.
Liefert die Ganzzahl zurück, auf die auf- oder abgerundet wurde.
<xsl:value-of select="round(betrag)" /><xsl:text >.-</xsl:text>
Im Beispiel wird von einem XML-Element namens betrag angenommen, dass es einen "krummen" Wert enthält, der kaufmännisch gerundet werden soll. Dazu wird beim Auswählen des Inhalts von betrag mit xsl:value-of im select-Attribut die Funktion round() aufgerufen. Sie bewirkt, dass der Elementinhalt aufgerundet wird, bevor er in den Ergebnisbaum der Datenausgabe übernommen wird.
starts-with() (Überprüfen, ob Zeichenkette mit bestimmter Teilzeichenkette beginnt)
Findet heraus, ob am Beginn einer Zeichenkette eine bestimmte Teilzeichenkette vorkommt.
Erwartet folgende Argumente:
- [Zeichenkette]: Zeichenkette, die durchsucht werden soll. Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln.
- [Teilzeichenkette]: Diejenige Zeichenfolge, nach der am Beginn der durchsuchten Zeichenkette gesucht wird. Es kann sich direkt um Text handeln, aber auch um den Inhalt eines Knotens oder den Wert einer Variablen.
Liefert true zurück, wenn die Zeichenkette mit der Teilzeichenkette beginnt, und false, wenn sie nicht damit beginnt.
<xsl:template match="mitarbeitername">
<p>
<xsl:if test="starts-with(.,'Frau')">
<b><xsl:value-of select="." /></b>
</xsl:if>
<xsl:if test="starts-with(.,'Herr')">
<i><xsl:value-of select="." /></i>
</xsl:if>
</p>
</xsl:template>
Im Beispiel wird für ein XML-Element namens mitarbeitername ein Template definiert. Dabei wird mit xsl:if abgefragt, ob der Elementinhalt mit Frau oder mit Herr beginnt. Im Fall "Frau" wird der Name in Fettschrift in den HTML-Ergebnisbaum geschrieben. Einträge, die mit Herr beginnen, werden dagegen in Kursivschrift geschrieben. Die xsl:if-Abfrage benutzt dazu die Funktion starts-with(). Als Parameter werden der Funktion der Inhalt des aktuellen Knotens (.) übergeben, sowie die Suchzeichenfolge Frau bzw. Herr.
string() (Argument in Zeichenkette umwandeln)
Interpretiert ein übergebenes Argument als Zeichenkette und gibt die ermittelte Zeichenkette zurück. Wenn beispielsweise 31 übergeben wird, wird "31" zurückgeliefert. Negative Zahlen erhalten ein vorangestelltes Minuszeichen, Bruchzahlen einen Dezimalpunkt. Bei Übergabe von booleschen Werten, also true oder false, wird "true" bzw. "false" als Zeichenkette zurückgeliefert.
Erwartet folgende Argumente:
- [Argument]: (optional) Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln, oder um den Rückgabewert einer anderen Funktion. Fehlt das Argument, wird die Funktion auf den aktuellen Knoteninhalt angewendet, z. B. auf den Inhalt eines Elements.
Liefert die ermittelte Zeichenkette zurück.
<xsl:template match="spannung">
<xsl:value-of select="string()" /><b><xsl:text> Volt</xsl:text></b>
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens spannung. Das Template gibt den Wert des Elements aus, jedoch wird dabei der numerische Inhalt in eine Zeichenkette umgewandelt. Dazu wird im select-Attribut der xsl:value-of-Anweisung die Funktion string() angewendet. Da string() kein Argument übergeben wird, bezieht sich die Funktion auf den Wert des aktuellen Elements.
string-length() (Anzahl Zeichen einer Zeichenkette ermitteln)
Ermittelt, wie lang eine Zeichenkette ist.
Erwartet folgende Argumente:
- [Zeichenkette]: (optional) Zeichenkette, deren Länge ermittelt werden soll. Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln. Falls das Argument keine Zeichenkette ist, sondern beispielsweise eine Zahl, wird es zunächst intern mit der string()-Funktion in eine Zeichenkette umgewandelt. Fehlt das Argument, wird die Funktion auf den aktuellen Knoteninhalt angewendet, z. B. auf den Inhalt eines Elements.
Liefert die Anzahl der Zeichen zurück.
<xsl:template match="mitteilungstext">
<xsl:choose>
<xsl:when test="string-length() < 20">
<p><b>Fehler: zu geringe Mitteilungsmenge!</b></p>
</xsl:when>
<xsl:otherwise>
<p><xsl:value-of select="." /></p>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens mitteilungstext. Der Inhalt dieses Elements soll nur dann in den Ergebnisbaum übernommen werden, wenn er mindestens 20 Zeichen besitzt. Dazu wird mit xsl:choose eine logische Verzweigung realisiert. Im xsl:when-Zweig wird abgefragt, ob der Elementinhalt kleiner als 20 Zeichen ist. Dazu wird die Funktion string-length() angewendet. Da kein Argument übergeben wird, bezieht sie sich automatisch auf den Inhalt des aktuellen Elements. Wenn weniger als 20 Zeichen ermittelt werden, wird eine Fehlermeldung in die Ausgabe geschrieben. Andernfalls (xsl:otherwise) wird der Inhalt von mitteilungstext in den Ergebnisbaum geschrieben.
substring() (Teilzeichenkette aus Zeichenkette extrahieren)
Extrahiert aus einer Zeichenkette einen Teil ab einer bestimmten Zeichenposition und auf Wunsch eine bestimmte Anzahl von Zeichen.
Erwartet folgende Argumente:
- [Zeichenkette] Zeichenkette, aus der ein Teil extrahiert werden soll. Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln. Falls das Argument keine Zeichenkette ist, sondern beispielsweise eine Zahl, wird es zunächst intern mit der string()-Funktion in eine Zeichenkette umgewandelt.
- [Zahl] Position innerhalb der Zeichenkette, ab der extrahiert werden soll. Wenn z. B. ab dem 1. Zeichen extrahiert werden soll, muss 1 übergeben werden, wenn ab dem 20. Zeichen extrahiert werden soll, ist 20 zu übergeben.
- [Zahl] (optional) Anzahl der Zeichen, die extrahiert werden sollen. Fehlt dieses Argument, wird bis zum Ende der Zeichenkette extrahiert.
Liefert die extrahierte Teilzeichenkette zurück.
<xsl:template match="ort">
<tr>
<td><xsl:value-of select="substring(.,1,5)" /></td>
<td><xsl:value-of select="substring(.,7)" /></td>
</tr>
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens ort, von dem angenommen wird, dass es Daten in der Form 81379 München enthält. Postleitzahl und Ortsname sollen bei der Ausgabe in den Ergebnisbaum auseinandergenommen und in zwei getrennte Tabellenzellen übernommen werden. Dazu wird dem select-Attribut der xsl:value-of-Anweisung jeweils die Funktion substring() zugewiesen. Sie extrahiert beim ersten der beiden Aufrufe für den Inhalt des aktuellen Elements, der mit current() bzw. . ermittelt wird, die ersten 5 Zeichen, also die Postleitzahl, und beim zweiten Aufruf die Zeichen ab Position 7 bis zum Ende der Ortsangabe, also den Ortsnamen ohne die Postleitzahl.
substring-after() (Zeichenkette ab einer Position mit Teilzeichenkette ermitteln)
Prüft, ob eine Zeichenkette eine bestimmte Teilzeichenkette enthält. Ist das der Fall, wird diejenige Restzeichenkette zurückgegeben, die nach dem ersten Vorkommen der Teilzeichenkette folgt. Dies ist z. B. sinnvoll, um in Daten, die aus dem Schema Variablenname=zugewiesener Wert bestehen, den Wert zu extrahieren. Analog dazu arbeitet die Funktion substring-before(), die aus den gleichen Daten den Variablennamen extrahieren kann.
Erwartet folgende Argumente:
- [Zeichenkette] Zeichenkette, aus der ein Teil extrahiert werden soll. Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln. Falls das Argument keine Zeichenkette ist, sondern beispielsweise eine Zahl, wird es zunächst intern mit der string()-Funktion in eine Zeichenkette umgewandelt.
- [Teilzeichenkette] Zeichenkette, die in der zuvor angegebenen Zeichenkette vorkommen soll. Es kann sich auch um ein einzelnes Zeichen handeln.
Liefert die Restzeichenkette hinter der Teilzeichenkette zurück, falls die Teilzeichenkette gefunden wurde. Andernfalls wird eine leere Zeichenkette zurückgegeben. Die Gegenfunktion substring-before() gibt dementsprechend den Teil der Zeichenkette zurück, der vor der Teilzeichenkette steht.
<xsl:template match="config-eintrag">
<th><xsl:value-of select="substring-before(current(),'=')" /></th>
<td><xsl:value-of select="substring-after(current(),'=')" /></td>
</xsl:template>
Das Beispiel nimmt an, dass es ein XML-Element namens config-eintrag gibt, in dem Bezeichnungen und Werte durch ein Gleichheitszeichen getrennt sind, z. B. Breite=475m. In der Template-Definition für dieses Element sollen der Teil vor dem Gleichheitszeichen in eine HTML-Tabellenkopfzelle übernommen werden, und der Teil hinter dem Gleichheitszeichen in eine Tabellendatenzeile. Dazu wird im ersten Teil dem select-Attribut der xsl:value-of-Anweisung zuerst die Funktion substring-before() zugewiesen, im zweiten Teil die Funktion substring-after(). In beiden Fällen wird der Inhalt des aktuellen Elements, ermittelt mit current(), durchsucht. Als Zeichenkette, die das Signal für die davor bzw. dahinter zu extrahierende Teilzeichenkette ist, dient das Gleichheitszeichen.
substring-before() (Zeichenkette vor einer Position mit Teilzeichenkette ermitteln)
Ist die Gegenfunktion zu substring-after(). Beispiel siehe dort.
sum() (Summe von Zahlenwerten ermitteln)
Ermittelt die Gesamtsumme der Zahlenwerte des Ausgangsknotens. Wenn Werte nicht als Zahl interpretiert werden können, wird NaN (not a number) ermittelt.
Erwartet folgende Argumente:
- [Knoten-Set] Ein Knoten-Set, für das die Summe seiner in Zahlen interpretierten Werte ermittelt werden soll. Sinnvollerweise enthält das Knoten-Set mehrere Knoten mit Werten, die als Zahlen interpretierbar sind, und deren Summe aus irgendeinem Grund interessant ist.
Liefert die Summe der ermittelten Werte zurück.
<xsl:template match="viereck">
<p>
<b><xsl:value-of select="name()" /> Umfang:</b><xsl:value-of select="sum(@*)" />cm
</p>
</xsl:template>
Das Beispiel zeigt eine Template-Definition für ein XML-Element namens viereck, das etwa so notiert sein könnte:
<viereck links="12" rechts="12" oben="20" unten="20" />
In der Übersetzung nach HTML wird einfach in einem Textabsatz der Umfang des Vierecks ausgegeben. Dazu wird mit select="sum(@*)" die Summe aller Attributwerte des viereck-Elements ermittelt. Bei dem zuvor notierten XML-Beispiel würde also 64 herauskommen, da dies die Summe der Attributwerte 12, 12, 20 und 20 ist. Das Argument @*, das im Beispiel der Funktion sum() übergeben wird, steht für "alle Attribute des Elements".
system-property() (Systemeigenschaften ermitteln)
Ermittelt Informationen über den verwendeten XSLT-Prozessor.
Erwartet folgende Argumente:
- [Zeichenkette] Eine Eigenschaft des XSLT-Prozessors. Folgende Angaben sollten von jedem XSLT-Prozessor unterstützt werden:
- 'xsl:version' (Version des XSLT-Standards, der vom Prozessor interpretiert wird),
- 'xsl:vendor' (Hersteller der Prozessor-Software) und
- 'xsl:vendor-url' (URI des Herstellers der Prozessor-Software).
Liefert den ermittelten Wert zurück.
<xsl:template match="zusatzinfos">
<p><b><xsl:text>XSL Version: </xsl:text></b>
<xsl:value-of select="system-property('xsl:version')" /></p>
<p><b><xsl:text>XSL Prozessor-Hersteller: </xsl:text></b>
<xsl:value-of select="system-property('xsl:vendor')" /></p>
<p><b><xsl:text>Hersteller URL-Adresse: </xsl:text></b>
<xsl:value-of select="system-property('xsl:vendor-url')" /></p>
</xsl:template>
Das Beispiel zeigt, wie man ein XML-Element, das in den XML-Daten beispielsweise als leeres Element definiert sein könnte, als Signalgeber benutzen kann, um in einer XSLT-Transformation an die betreffende Stelle bestimmte Daten einzusetzen. Im Beispiel wird ein XML-Element namens zusatzinfos angenommen, das so eine Funktion hat. Denn in der Template-Definition für dieses Element wird nicht dessen Inhalt ausgegeben, sondern es werden mit der system-property()-Funktion diverse Eigenschaften des verwendeten XSLT-Prozessors ermittelt und in den HTML-Ergebnisbaum mit übernommen. Dazu werden jeweils den select-Attributen der xsl:value-of-Anweisungen Aufrufe von system-property() übergeben.
translate() (Suchen und Ersetzen von Zeichen in einer Zeichenkette)
Ersetzt einzelne Zeichen in einer Zeichenkette in andere Zeichen.
Erwartet folgende Argumente:
- [Zeichenkette] Zeichenkette, in der gesucht und ersetzt werden soll. Es kann sich z. B. um den Inhalt eines Elements oder den Wert einer Variablen handeln. Falls das Argument keine Zeichenkette ist, sondern beispielsweise eine Zahl, wird es zunächst intern mit der string()-Funktion in eine Zeichenkette umgewandelt.
- [Zeichen] Ein oder mehrere Zeichen, die ersetzt werden sollen.
- [Zeichen] Ein oder mehrere Zeichen, durch welche die zuvor angegebenen Zeichen ersetzt werden sollen. Mögliche Angaben sind z. B. ',' oder ']['. Dieses Argument muss übergeben werden, kann aber auch einen leeren Inhalt haben (). Dann werden die Zeichen, die im zweiten Argument genannt sind, einfach durch nichts ersetzt, also gelöscht.
Liefert die behandelte Zeichenkette zurück.
<xsl:template match="ortsname">
<b>
<xsl:value-of select="translate(current(),'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ')" />
</b>
</xsl:template>
Das Beispiel definiert ein Template für ein XML-Element namens ortsname. Der Inhalt des Elements wird in den Ergebnisbaum ausgegeben, doch dabei werden alle Kleinbuchstaben in Großbuchstaben umgewandelt. Zu diesem Zweck wird dem select-Attribut der xsl:value-of-Anweisung die Funktion translate() zugewiesen. Diese bestimmt für den Inhalt des aktuellen Elements, ermittelt mit current(), dass die Kleinbuchstaben von a bis z durch entsprechende Großbuchstaben ersetzt werden.
true() (booleschen Wert für "wahr" erzeugen)
Bejaht einen Ausdruck.
Erwartet keine Argumente
Liefert einfach den logischen Wert true zurück.
<xsl:variable name="passwortanzeige" select="true()"/>
<xsl:template name="passwort">
<xsl:choose>
<xsl:when test="$passwortanzeige">
<xsl:value-of select="." />
</xsl:when>
<xsl:otherwise>
<xsl:text>[Passwort]</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
Im Beispiel wird mit xsl:variable eine Variable namens passwortanzeige definiert, deren Wert auf den logischen Wert true gesetzt wird. Verantwortlich dafür ist der Einsatz der Funktion true(), die einfach dem select-Attribut zugewiesen wird und dadurch für das Setzen des Wertes sorgt. Weiterhin zeigt das Beispiel eine Template-Definition für ein Element namens passwort. Innerhalb dieser Template-Definition wird in einer xsl:choose-Konstruktion abgefragt, wie es mit der Passwortanzeige steht. Wenn die Variable $passwortanzeige wahr ist, wird mit <xsl:value-of select="." /> der Wert des passwort-Elements ausgegeben. Andernfalls wird nur die Zeichenkette [Passwort] ausgegeben.
unparsed-entity-uri() (ungeparste Einträge der DTD ermitteln)
Erlaubt es, auf DTD-Einträge zuzugreifen, die vom Parser nicht analysiert wurden. Dies betrifft vor allem Entities für externe Ressourcen.
Erwartet folgende Argumente:
- [Name] Der Name des nicht geparsten DTD-Eintrags (Entities).
Liefert den URI des Entities zurück, der hinter SYSTEM oder PUBLIC angegeben ist. Die entsprechende Adresse kann dann im Ergebnisbaum an eine geeignete Stelle eingesetzt werden.
<!ENTITY firmenlogo SYSTEM "images/logo.jpg" NDATA JPEG>
<bild quelle="firmenlogo" />
<xsl:template match="bild">
<img src="{unparsed-entity-uri(@quelle)}" alt="Firmenlogo" />
</xsl:template>
Das Beispiel zeigt eine externe Entity-Definition in einer DTD. Dort wird ein Entity namens firmenlogo definiert, das eine JPEG-Grafik zugewiesen bekommt. Im zweiten Teil des Beispiels wird gezeigt, wie dieses Entity in einer XML-Datei zur Anwendung gelangt. Ein XML-Element namens bild hat ein Attribut namens quelle, dem das Entity zugewiesen wird. Der dritte Teil des Beispiels schließlich zeigt eine zugehörige Definition im XSL-Stylesheet. Dort wird für das Element bild ein Template definiert, in dem das XML-Konstrukt in ein HTML-Konstrukt zum Anzeigen einer Grafik übersetzt wird. Dem src-Attribut des img-Elements wird dabei die Funktion unparsed-entity-uri() zugewiesen. Der Funktion wird als Argument das Attribut @quelle des bild-Elements übergeben. Die Funktion liefert den zugehörigen URI wie in der DTD definiert zurück, also images/logo.jpg.
