# XPath-Funktionen

Hinweise zu den XPath-Funktionen
boolean() (Argument als wahr oder falsch bewerten)
ceiling() (Zahl aufrunden)
concat() (Zeichenketten zu einer zusammenfassen)
contains() (auf bestimmte Teilzeichenkette überprüfen)
count() (Anzahl Knoten in einem Knoten-Set ermitteln)
current() (aktuellen Knoten ermitteln)
document() (anderes XML-Dokument aufrufen)
element-available() (Verfügbarkeit eines XSLT-Elements überprüfen)
false() (booleschen Wert für "falsch" erzeugen)
floor() (Zahl abrunden)
format-number() (Zahl in Zeichenkette umwandeln)
function-available() (Verfügbarkeit einer XPath-Funktion überprüfen)
generate-id() (eindeutigen Bezeichner für ein Element generieren)
id() (Element mit bestimmtem Bezeichner auswählen)
key() (Elemente mit Hilfe eines Schlüsselwerts auswählen)
lang() (Element auf bestimmten Sprachcode überprüfen)
last() (Positionsnummer des letzten Knotens einer Reihe ermitteln)
local-name() (lokalen Namen eines Knoten-Sets ermitteln)
name() (Namen eines Knoten-Sets ermitteln)
namespace-uri() (Namensraum eines Elements ermitteln)
normalize-space() (Leerzeichen am Anfang und Ende einer Zeichenkette entfernen)
not() (Argument verneinen)
number() (Argument in eine Zahl umwandeln)
position() (Positionsnummer des aktuellen Knotens ermitteln)
round() (kaufmännisch auf- oder abrunden)
starts-with() (Überprüfen, ob Zeichenkette mit bestimmter Teilzeichenkette beginnt)
string() (Argument in Zeichenkette umwandeln)
string-length() (Anzahl Zeichen einer Zeichenkette ermitteln)
substring() (Teilzeichenkette aus Zeichenkette extrahieren)
substring-after() (Zeichenkette ab einer Position mit Teilzeichenkette ermitteln)
substring-before() (Zeichenkette vor einer Position mit Teilzeichenkette ermitteln)
sum() (Summe von Zahlenwerten ermitteln)
system-property() (Systemeigenschaften ermitteln)
translate() (Suchen und Ersetzen von Zeichen in einer Zeichenkette)
true() (booleschen Wert für "wahr" erzeugen)
unparsed-entity-uri() (ungeparste Einträge der DTD ermitteln)

## Hinweise zu den 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.

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

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:value-of select="ceiling(betrag)" /><xsl:text>.-</xsl:text>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:value-of select="concat(vorname, ' heißt mit Zuname ', zuname)"/>

### Erläuterung:

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`. Beachten Sie, dass Variablennamen, Elementnamen (oder Elementpfade nach XPath-Syntax) direkt angegeben werden, feste Zeichenketten dagegen in Anführungszeichen eingeschlossen werden. Dabei muss es sich um andere Anführungszeichen handeln als bei dem XSLT-Attribut, innerhalb dessen die Funktion steht. Wenn die Funktion, wie beim Beispiel im `select`-Attribut, in dessen doppelten Anführungszeichen `"..."` vorkommt, müssen einfache Anführungszeichen verwendet werden, so wie im Beispiel `' heißt mit 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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:if test="contains(zuname, 'A')">
      <xsl:value-of select="zuname" />
    </xsl:if>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:value-of select="current()" />

### Erläuterung:

Die Anweisung im Beispiel drückt das gleiche aus wie die üblichere Anweisung:
`<xsl:value-of select="." />`

### Beachten Sie:

`current()` und `.` liefern dann das gleiche Ergebnis, wenn `current()` in einem freistehenden XPath-Ausdruck steht, also z.B. direkt in einem `select`-Attribut. Wenn Sie `current()` dagegen in einem Prädikat (steht immer zwischen `[...]`) anwenden, kann das zurückgelieferte Ergebnis ein anderes sein als das Ergebnis von `select="."`. Der Grund ist, dass XPath intern zwischen "current node" und "context node" unterscheidet. Ein "current node", also ein aktueller Knoten, ist nur dann gegeben, wenn ein Knoten-Set der Reihe nach abgearbeitet wird. In diesem Fall ist der jeweils bearbeitete Knoten der "current node". Außerhalb einer solchen Serienbearbeitung gibt es jedoch keinen "current node". Einen "context node", wie man ihn durch die Punkt-Syntax (`.`) ermitteln kann, ist dagegen zu jedem Zeitpunkt gegeben.

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

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="beispiel">
     <pre>
      <xsl:value-of select="document(./@quelle)" />
     </pre>
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:if test="element-available('xsl:number')">
       <xsl:number level="single" count="eintrag" format="1. " />
     </xsl:if>

### Erläuterung:

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.

### Beachten Sie:

Dieser Funktion ist auch dann nützlich, wenn es darum geht herauszufinden, ob der XSLT-Prozessor Hersteller-spezifische Erweiterungen kennt, z.B.:
`<xsl:when test="element-available('saxon:entity-ref')">...</xsl:when>`.
In diesem Beispiel wird abgefragt, ob der Prozessor das Element `entity-ref` kennt, das der Saxon-Prozessor interpretiert.

## false() (booleschen Wert für "falsch" erzeugen)

Verneint einen Ausdruck.

Erwartet keine Argumente

Liefert einfach den logischen Wert `false` zurück.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="zahl">
     <div style="background-color:yellow"><xsl:value-of select="floor(./@wert)" /></div>
    </xsl:template>

### Erläuterung:

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 xsl:decimal-format definiert wird.

Liefert eine Zeichenkette mit der formatierten Zahl zurück.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="wert">
     <xsl:value-of select="format-number(.,'##0.0%')" />
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="absatz">
    <p><a name="{generate-id(.)}">
     <xsl:value-of select="." />
    </a></p>
    </xsl:template>

### Erläuterung:

Das Beispiel definiert ein Template für ein häufiger vorkommendes XML-Element namens `absatz`. Jedes dieser Elemente erhält bei der Übersetzung in ein HTML-Konstrukt einen Anker, definiert mit `<a name=>...</a>`. Der Wert, der jeweils beim Attribut `name` vergeben wird, wird automatisch erzeugt, und zwar durch Anwendung der Funktion `generate-id()`. Als Argument wird das aktuelle Element (`.`) übergeben. Wichtig sind die geschweiften Klammern, in denen die Funktion bei der Wertzuweisung an `name` zusätzlich steht. Dies ist nötig, weil die Funktion in diesem Beispiel nicht in der Wertzuweisung an ein Attribut einer XSLT-Anweisung steht, sondern in einer Wertzuweisung an ein Attribut eines Elements des Ergebnisbaums - im Beispiel an das `name`-Attribut des `a`-Elements der Ergebnissprache HTML.

### Beachten Sie:

`generate-id()` kann man auch dazu verwenden, um herauszufinden, ob Knoten identisch sind. Beispiel:
`<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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="name">
    <li><xsl:value-of select="id('p01')" /><xsl:value-of select="." /></li>
    </xsl:template>

### Erläuterung:

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

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="zahl">
     <xsl:value-of select="." />
     <xsl:if test="position() != last()">
      <xsl:text>, </xsl:text>
     </xsl:if>
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template name="Kurzbeschreibung">
     <b><xsl:value-of select="name()" /><xsl:text>: </xsl:text></b><xsl:value-of select="." />
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem 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="/">
     <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>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="augenfarbe">
      <tr>
      <td><xsl:text>Augenfarbe</xsl:text></td>
      <td><xsl:value-of select="normalize-space()" /></td>
      </tr>
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="geburtsjahr">
     <xsl:if test="not(. &gt; '1980')">
      <xsl:value-of select="." />
     </xsl:if>
    </xsl:template>

### Erläuterung:

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 `. &gt; '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=". &lt;='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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="preis">
     <xsl:value-of select="number()" />
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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`

### Beachten Sie:

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

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:value-of select="round(betrag)" /><xsl:text >.-</xsl:text>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="spannung">
     <xsl:value-of select="string()" /><b><xsl:text> Volt</xsl:text></b>
    </xsl:template>

### Erläuterung:

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

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

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="mitteilungstext">
      <xsl:choose>
       <xsl:when test="string-length() &lt; 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>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="viereck">
    <p>
    <b><xsl:value-of select="name()" /> Umfang:</b><xsl:value-of select="sum(@*)" />cm
    </p>
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

    <xsl:template match="ortsname">
     <b>
     <xsl:value-of select="translate(current(),'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ')" />
     </b>
    </xsl:template>

### Erläuterung:

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.

### Beispielauszug aus einem XSL-Stylesheet:

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

### Erläuterung:

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.

### Beispielauszug aus einer DTD:

    <!ENTITY firmenlogo SYSTEM "images/logo.jpg" NDATA JPEG>

### Beispielauszug aus einer entsprechenden XML-Datei:

    <bild quelle="firmenlogo" />

### Beispielauszug aus einem zugehörigen XSL-Stylesheet:

    <xsl:template match="bild">
     <img src="{unparsed-entity-uri(@quelle)}" alt="Firmenlogo" />
    </xsl:template>

### Erläuterung:

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`.
Beachten Sie die geschweiften Klammern, die erforderlich sind, wenn eine XPath-Funktion im Code des Ergebnisbaums verwendet wird. Mehr dazu im Abschnitt über XPath-Syntax.

| Einführung in JavaScript und DOM
| XPath-Syntax

© 2007 Impressum