| # XPath-Syntax
| Die Aufgaben von XPath Knotentypen, Achsen und Pfade Ausführliche und verkürzte Notation Adressierung der Dokumentwurzel Adressierung mit absoluten Pfadangaben Adressierung mit relativen Pfadangaben Adressierung von Attributen Adressierung mit Wildcards Adressierung mit Positionsangaben und Bedingungen XPath-Operatoren

## Die Aufgaben von XPath

XPath ist ebenso wie XML, XSL und XSLT ein Sprachprojekt des W3-Konsortiums. Für XPath gibt es eine eigene Arbeitsgruppe, die an der Spezifikation der XPath-Sprache arbeitet. Im November 1999 ist dabei die Version 1.0 der Empfehlung (Recommendation) für XPath herausgekommen. Die jeweils aktuelle Spezifikation und die Fortentwicklung der XPath-Sprache können Sie über die W3C-Einstiegsseite zu XPath mitverfolgen.

XPath ist jedoch lediglich eine Art Hilfssprache, die erforderlich ist, damit XSLT seine Aufgaben wahrnehmen kann. XPath hat dabei drei wichtige Aufgaben:

- Adressierung von Daten
- Definition logischer Ausdrücke
- Zusätzliche Funktionen

### Adressierung von Daten

Beim Übersetzen einer XML-Dokumentstruktur in eine andere XML-Dokumentstruktur, also etwa beim Übersetzen eines Dokuments mit eigener XML-DTD in ein HTML-Dokument, ist es wichtig, jeden Bestandteil der Datenstruktur genau ansprechen zu können. Wenn Sie im (XML-)Ausgangsbaum beispielsweise stehen haben: `<augen farbe="graublau">`, und Sie möchten im (HTML-)Ergebnisbaum daraus erzeugen: `<th>Augenfarbe</th><td>graublau</td>`, dann müssen Sie auf das Attribut `farbe` des Elements `augen` zugreifen. Angenommen weiter, das Element `augen` ist sowohl ein Kindelement eines Elements namens `person`, als auch ein Kindelement eines Elements namens `phantombilddaten` in einem anderen Zweig des gleichen XML-Dokuments, können Sie erahnen, dass für die eindeutige Adressierung von Dokumentbestandteilen eine brauchbare Adressierungs-Syntax benötigt wird. Typische Fälle, in denen die XPath-Adressierung zum Einsatz kommt, sind z.B. das `select`-Attribut der xsl:value-of-Anweisung oder das `match`-Attribut der xsl:template-Anweisung.

Das Adressieren von Daten mit XPath wird auf dieser Seite weiter unten beschrieben.

### Definition logischer Ausdrücke

Damit sind logische Ausdrücke gemeint, die vom XSLT-Prozessor mit verarbeitet werden, und die zur Funktionalität bestimmter XSLT-Elemente wichtig sind. Logische Ausdrücke enthalten Operatoren und können damit z.B. zwei Werte vergleichen. Ähnlich wie die Adressierung von Daten kommt die Definition von Ausdrücken in bestimmten Wertzuweisungen an Attribute von XSLT-Elementen vor. Ein typisches Beispiel ist das `test`-Attribut der xsl:if-Anweisung. Darin wird eine Bedingung formuliert, die wahr oder falsch sein kann. Nur wenn sie wahr ist, werden untergeordnete Anweisungen ausgeführt. Eine Bedingung wie `test="alter &gt;= 18"` (hat das Element `alter` einen Wert größer gleich 18?) ist so ein typischer logischer Ausdruck. Die Syntax dabei basiert auf XPath.

Die Definition von logischen Ausdrücken mit XPath wird auf dieser Seite im Abschnitt XPath-Operatoren beschrieben.

### Zusätzliche Funktionen

Seinen großen Leistungsumfang erhält XSLT nicht zuletzt durch ein Arsenal an zusätzlichen Funktionen, die bestimmte Aufgaben wahrnehmen. So gibt es z.B. eine Funktion `position()`, die beim Abarbeiten mehrerer Elemente in einer Reihe zurückliefert, das wievielte Element gerade bearbeitet wird. Diese Information lässt sich beispielsweise dazu nutzen, um die Elemente im Ergebnisbaum zu nummerieren. Eine andere typische Funktion namens `starts-with()` überprüft, ob eine Zeichenkette mit einer bestimmten Teilzeichenkette beginnt. Wenn diese Funktion etwa als Bedingung in einer `xsl:if`-Anweisung notiert wird, lässt sich das Erzeugen des Ergebnisbaums von der Abfrage beeinflussen, ob der Wert eines Elements mit einem bestimmten Zeichen oder einer bestimmten Zeichenfolge beginnt. So könnte eine Bedingung wie `test="starts-with(plz,'8')"` zum Beispiel abfragen, ob der Wert einer Postleitzahl mit `8` beginnt, und nur Elemente in den Ergebnisbaum übernehmen, bei denen dies der Fall ist.

Die zusätzlichen Funktionen werden auf der Seite XPath-Funktionen beschrieben.

## Knotentypen, Achsen und Pfade

XML-gerechte Dokumente sind wie die Verzeichnis- und Dateistruktur auf einem Datenträger aufgebaut. Dort gibt es ein Wurzelverzeichnis, das Verzeichnisse (Ordner) und Dateien enthalten kann. Jedes untergeordnete Verzeichnis kann wiederum andere Unterverzeichnisse und Dateien enthalten usw. Man spricht dabei auch von Baumstruktur. Auf der Seite Baumstruktur und Knoten einer XML-Datei wird dieses Modell einführend beschrieben.

Ebenso, wie man bei der Dateistruktur auf einem Datenträger von Verzeichnissen oder Ordnern, Dateien und Pfadangaben für Dateien spricht, braucht man für die Adressierung von Bestandteilen eines XML-Dokuments eine geeignete Terminologie. Zu diesem Zweck gibt es in XPath verschiedene Knotentypen, Achsen und Pfade. Die Begriffe, die dabei auftauchen, werden im folgenden vorgestellt. Die Begriffe muten zunächst etwas akademisch an, aber zum Verständnis von XPath sind sie wichtig. Entscheidend sind die englischen Originalbegriffe (kursiv geschrieben).

### Knotentypen

Jeder Bestandteil der Baumstruktur einer XML-Datei wird als Knoten bezeichnet. Da es in XML jedoch durchaus namhaft zu machende Bestandteile wie Elemente, Attribute usw. gibt, wird von entsprechenden Knotenypen gesprochen. Die Knotentypen sind nicht unmittelbar Bestandteil der Adressierungs-Syntax von XPath, doch es ist sinnvoll, die Begriffe zu kennen. XPath unterscheidet 7 Knotentypen:

Knotentyp | Bedeutung
--- | ---
Wurzelknoten (root node) | Dies ist die Wurzel eines XML-Dokuments. Der Wurzelknoten ist selbst kein Element, sondern nur die abstrakte Ursprungswurzel der Baumstruktur des Dokuments.
Elementknoten (element node) | Jedes Element (auch das Dokument-Element) stellt aus XPath-Sicht einen Elementknoten dar. Ein Element namens `a`, bestehend aus dem Anfangs- und End-Tag `<a>...</a>`, ist beispielsweise ein element node. Untergeordnete Elemente (auch als Kindelemente bezeichnet) sind ebenfalls element nodes, also beispielsweise ein Element namens `b`, bestehend aus dem Anfangs- und End-Tag `<b>...</b>`, das innerhalb von `<a>...</a>` vorkommen kann.
Attributknoten (attribute node) | Jedes Attribut, das zu einem Element gehört, wird als Attributknoten bezeichnet. Ein Attribut `b="irgendwas"`, das im Anfangs-Tag eines Elements `a` vorkommt und dann also in der Form `<a b="irgendwas">` notiert wird, gilt als attribute node des Elements `a`. Der Attributknoten besteht also aus dem Attributnamen und dem zugewiesenen Wert.
Textknoten (text node) | Jeder Zeicheninhalt, der keine anderen Knoten mehr enthält, wird als Textknoten bezeichnet. In einer Notation wie `<a b="irgendwas">und ein kleiner Text</a>` ist der Inhalt des Elements ein text node.
Namensraumknoten (namespace node) | Sowohl Elemente als auch Attribute können Namensraumangaben enthalten, wenn entsprechende Namensräume in eine XML-Datei importiert werden. Ähnlich wie Attributknoten einem Elementknoten zugeordnet sind, sind Namensraumknoten einem Elementknoten oder einem Attributknoten zugeordnet. Bei einer Notation wie `<x:a y:b="irgendwas">` sind `x` und `y` Namensraumangaben. `x` ist ein namespace node, der dem Element `a` zugeordnet ist, und `y` ein namespace node, der dem Attribut `b` zugeordnet ist.
Verarbeitungsanweisungsknoten (processing instruction node) | Verarbeitungsanweisungen, die in einem XML-Dokument vorkommen (sie beginnen mit `<?` und enden mit `?>`), stehen außerhalb des eigentlichen Dokumentbaums. Sie stellen aus XPath-Sicht einen eigenen Knotentyp dar, wobei das Ziel der Verarbeitungsanweisung den Namen des Knoten und der Rest den Inhalt des Knotens bildet. In einer Verarbeitungsanweisung wie `<?xml-stylesheet type="text/xsl" href="darstellung.xsl"?>` ist der Teil `xml-stylesheet` der Name des Knotens. Die XML-Deklaration `<?xml version="1.0"?>`, die zu Beginn einer XML-Datei notiert werden sollte, ist allerdings keine Verarbeitungsanweisung in diesem Sinne, auch wenn sie syntaktisch genau so aussieht.
Kommentarknoten (comment node) | Kommentare, also Inhalte, die in die Zeichenfolgen `<!--` und `-->` eingeschlossen sind, werden als Kommentarknoten bezeichnet. Der Kommentarknoten ist dabei der Inhalt des Kommentars. Bei einem Kommentar wie `<!--irgendwas-->` ist die Zeichenfolge `irgendwas` der comment node.

### Achsen

Die Baumstruktur eines XML-Dokuments ergibt für die einzelnen Knoten, dass diese verschiedene Beziehungen untereinander haben. So gibt es Knoten, die von anderen Knoten abhängen, und solche, die auf einer gemeinsamen Ebene liegen. Dafür hält XPath verschiedene Begriffe bereit, die aus der Verwandtschaftsterminologie stammen und als Achsen (axes) bezeichnet werden. Die englischen Begriffe (in der folgenden Tabelle kursiv dargestellt) werden auch bei der ausführlichen Adressierung verwendet. XPath unterscheidet 13 Achsen:

Achse | Bedeutung | Visualisierung
--- | --- | ---
Kind (child) | Unmittelbar untergeordnete Knoten. In einer Struktur wie `<a><b>...</b></a>` ist das Element `b` aus Sicht des Elements `a` ein child. | siehe grafische Darstellung
Elternknoten (parent) | Der unmittelbar übergeordnete Knoten. In einer Struktur wie `<a><b>...</b></a>` ist das Element `a` aus Sicht des Elements `b` ein parent. | siehe grafische Darstellung
Nachkommen (descendant) | Untergeordnete Knoten, auch solche, die weiter als unmittelbar untergeordnet sind. In einer Struktur wie `<a><b><c>...</c></b></a>` ist sowohl das Element `b` als auch das Element `c` aus Sicht des Elements `a` ein descendant. | siehe grafische Darstellung
Vorfahr (ancestor) | Übergeordnete Knoten, auch solche, die weiter als unmittelbar übergeordnet sind. In einer Struktur wie `<a><b><c>...</c></b></a>` ist sowohl das Element `b` als auch das Element `a` aus Sicht des Elements `c` ein ancestor. | siehe grafische Darstellung
Nachfolgende Knoten (following) | Knoten, die nach dem aktuellen Knoten im restlichen XML-Dokument folgen, unabhängig von der Hierarchie der Knoten (ausgeschlossen Nachkommen-Knoten des aktuellen Knotens). In einer Struktur wie `<a><b><c>...</c></b><b><c>...</c></b></a>` haben aus Sicht des ersten `c`-Elements das zweite `b`-Element, das zweite `c`-Element und dessen Inhalt den Status following. | siehe grafische Darstellung
Vorherige Knoten (preceding) | Knoten, die vor dem aktuellen Knoten im XML-Dokument stehen, unabhängig von der Hierarchie der Knoten (ausgeschlossen Vorfahr-Knoten des aktuellen Knotens). In einer Struktur wie `<a><b><c>...</c><c>...</c></b><b></b></a>` haben aus Sicht des zweiten `b`-Elements das erste `b`-Element und dessen Kind-Elemente den Status preceding. | siehe grafische Darstellung
Nachfolgende Geschwisterknoten (following-sibling) | Knoten, die nach dem aktuellen Knoten im restlichen XML-Dokument folgen, und zwar auf der gleichen Hierarchie-Ebene. In einer Struktur wie `<a><b><c>...</c><c>...</c></b></a><c>...</c>` hat aus Sicht des ersten `c`-Elements das zweite `c`-Element den Status following-sibling, das dritte `c`-Element dagegen nicht. | siehe grafische Darstellung
Vorherige Geschwisterknoten (preceding-sibling) | Knoten, die vor dem aktuellen Knoten im XML-Dokument stehen, und zwar auf der gleichen Hierarchie-Ebene. In einer Struktur wie `<c>...</c><a><b><c>...</c><c>...</c></b></a>` hat aus Sicht des dritten `c`-Elements das zweite `c`-Element den Status preceding-sibling, das erste `c`-Element dagegen nicht. | siehe grafische Darstellung
Attribut (attribute) | Attributknoten eines Elements. Attribute erhalten damit, obwohl auch sie ihren Platz in der Hierarchie einer XML-Dokumentstruktur haben, eine Sonderstellung und werden nicht in das Schema der Begriffe child, parent, descendant und ancestor eingefügt. In einer Struktur wie `<a b="irgendwas">` ist `b` aus Sicht von `a` ein attribute. |
Namensraum (namespace) | Zugehöriger Namensraumknoten des aktuellen Elements. In einer Struktur wie `<x:a>...</x:a>` ist aus Sicht des `a`-Elements `x` der zugehörige namespace. |
Der aktuelle Knoten selbst (self) | Der aktuelle Knoten. Wenn in einer Struktur wie `<a><b><c>...</c><c>...</c></b></a>` vom XSLT-Prozessor gerade das `b`-Element verarbeitet wird, dann hat dieses in dem Moment den Status self. | siehe grafische Darstellung
Nachkommen oder der aktuelle Knoten selbst (descendant-or-self) | Der aktuelle Knoten oder Nachkommen davon. Wenn in einer Struktur wie `<a><b><c>...</c><c>...</c></b></a>` vom XSLT-Prozessor gerade das `b`-Element verarbeitet wird, dann haben dieses und das nachfolgende `c`-Element in dem Moment den Status descendant-or-self. | siehe grafische Darstellung
Vorfahre oder der aktuelle Knoten selbst (ancestor-or-self) | Der aktuelle Knoten oder Vorfahren davon. Wenn in einer Struktur wie `<a><b><c>...</c><c>...</c></b></a>` vom XSLT-Prozessor gerade das `b`-Element verarbeitet wird, dann haben dieses und das vorhergehende `a`-Element in dem Moment den Status ancestor-or-self. | siehe grafische Darstellung

### Pfade

XPath stellt zwei syntaktische Mittel bereit, um den Pfad zu einem oder mehreren Knoten zu notieren:

Notation | Beschreibung | Bedeutung
--- | --- | ---
`/` | einfacher Schrägstrich | Pfad-Trennzeichen für tatsächliche Namen von Knoten. In einer Struktur wie `<a><b><c>...</c><c>...</c></b></a>` lässt sich das `c`-Element als Pfadangabe in der Form `a/b/c` darstellen.
`::` | doppelter Doppelpunkt | Pfad-Trennzeichen für Knotenangaben mit Achsen. In einer Struktur wie `<a><b><c>...</c><c>...</c></b></a>` lässt sich das `c`-Element als Pfadangabe z.B. in der Form `a/b/child::c` darstellen. Mehr dazu im folgenden Abschnitt.

## Ausführliche und verkürzte Notation

Beim Adressieren von Knoten einer XML-Datenstruktur gibt es Ausdrücke wie `/child::person/child::augen/attribute::farbe`. Solche Ausdrücke werden als ausführliche Notation bezeichnet, weil sie die vollen Achsenbezeichnungen enthalten. Der Ausdruck `/child::person/child::augen/attribute::farbe` kann jedoch ebensogut in der Form `/person/augen/@farbe` notiert werden. Dies ist die verkürzte Notation, die auf die Achsenbezeichnung `child::` verzichtet und einige andere Einsparungen erlaubt. In den Beispielen weiter unten werden die beiden Notationsvarianten jeweils parallel gezeigt.

## Adressierung der Dokumentwurzel

Jedes XML-Dokument hat eine Wurzel, die auch adressierbar ist.

### Beispiel:

    <xsl:template match="/">
    <html><head><title>Beispiel</title></head>
    <body>
     <xsl:apply-templates />
    </body></html>
    </xsl:template>

### Erläuterung:

Der Wurzelknoten eines XML-Dokuments wird mit einem einzelnen Schrägstrich (`/`) adressiert. Im Beispiel wird mit xsl:template ein Template für die XML-Dokumentwurzel definiert. Im `match`-Attribut wird die Dokumentwurzel adressiert.

## Adressierung mit absoluten Pfadangaben

Knoten eines XML-Dokuments sind mit Hilfe einer absoluten Pfadangabe adressierbar.

### Beispiel 1 (ausführliche Notation):

    <xsl:template match="/child::adresse/child::vorname">
    <b><xsl:value-of select="/child::adresse/child::vorname" /></b>
    </xsl:template>

### Beispiel 2 (verkürzte Notation):

    <xsl:template match="/adresse/vorname">
    <b><xsl:value-of select="/adresse/vorname" /></b>
    </xsl:template>

### Erläuterung:

Absolute Pfadangaben beginnen mit einem Schrägstrich (`/`), der die Dokumentwurzel repräsentiert. Weitere Hierarchie-Ebenen werden durch weitere Schrägstriche markiert. Die Knoten, über die der Pfad läuft, werden wie in Beispiel 1 gezeigt durch ihre Achse und den gewünschten Knotennamen bezeichnet, getrennt durch doppelten Doppelpunkt (`::`). Ebenfalls erlaubt und häufiger verwendet ist allerdings die in Beispiel 2 gezeigte verkürzte Notation ohne Achsenbezeichnungen. Im Beispiel wird mit der `xsl:template`-Anweisung ein Template für ein Element namens `vorname` definiert, das ein Kindelement des Elements `adresse` ist, das wiederum ein Kindelement der Dokumentwurzel ist. Auch im `select`-Attribut der xsl:value-of-Anweisung wird die Syntax verwendet.

## Adressierung mit relativen Pfadangaben

Knoten eines XML-Dokuments sind mit Hilfe einer relativen Pfadangabe adressierbar.

### Angenommene XML-Struktur:

    <liga>
     <liga-eintrag>
      <spieler>...</spieler>
       <ergebnis>
        <punktzahl>...</punktzahl>
       </ergebnis>
     </liga-eintrag>
    </liga>

### Beispiel 1 (ausführliche Notation):

    <xsl:template match="./child::liga-eintrag/child::ergebnis">
     <span class="normal"><xsl:value-of select="parent::spieler" /></span>
     <span class="betont"><xsl:value-of select="./child::punktzahl" /></span>
    </xsl:template>

### Beispiel 2 (verkürzte Notation):

    <xsl:template match="liga-eintrag/ergebnis">
     <span class="normal"><xsl:value-of select="../spieler" /></span>
     <span class="betont"><xsl:value-of select="punktzahl" /></span>
    </xsl:template>

### Erläuterung:

Das Beispiel nimmt eine typische verschachtelte Elementstruktur an. Es nimmt an, dass es für das Element `liga` eine Template-Definition gibt, in der mit der xsl:apply-templates-Anweisung untergeordnete Templates aufgerufen werden. Weiterhin nimmt das Beispiel an, dass für das Element `liga-eintrag` keine Template-Definition exisitert, erst wieder für dessen Kindelement `ergebnis`. Um dieses Element aus Sicht des Großvaterelements `liga` zu adressieren, ist eine relative Pfadangabe im `match`-Attribut der xsl:template-Anweisung nötig. In der ausführlichen Notation lautet diese Pfadangabe `./child::liga-eintrag/child::ergebnis`, in der verkürzten, leichter lesbaren Notation `liga-eintrag/ergebnis`. Die Zeichenfolge `./` (Punkt und Schrägstrich) steht für "aktueller Standpunkt". Diese Zeichenfolge kann auch weggelassen werden. Ansonsten besteht die relative Pfadangabe einfach aus der Folge der hierarchie-bestimmenden Knotennamen. Bei der ausführlichen Notation wird dabei stets noch die Achsenbezeichnung `child::` benutzt, während bei der verkürzten Notation die bloßen Knotennamen (im Beispiel die Elementnamen `liga-eintrag` und `ergebnis`) genügen. Trennzeichen für Hierarchie-Ebenen ist der einfache Schrägstrich (`/`).

Innerhalb der Template-Definition für das Element `ergebnis` wird unter anderem HTML-Code für ein anderes Element der Ausgangsdaten, nämlich für das Element `spieler` notiert. Dieses Element liegt jedoch auf der gleichen Hierarchie-Ebene wie das aktuelle Element `ergebnis` (Geschwisterknoten). Um es aus Sicht von `ergebnis` anzusprechen, muss es über den Umweg des gemeinsamen Elternelements adressiert werden. In der ausführlichen Notation steht dafür die Achsenbezeichnung `parent::` zur Verfügung, gefolgt vom Namen des anderen Kindknotens. In der verkürzten Notation genügt die Angabe von zwei Punkten, gefolgt von einem Schrägstrich (`../`), um den Weg über das Elternelement zu beschreiben.

Für die HTML-Ausgabe des Elements `punktzahl` wird ebenfalls eine relative Adressierung verwendet. Da das Element `punktzahl` aus Sicht des aktuellen Elements `ergebnis` einfach ein Kindelement ist, genügen die Angaben `./child::punktzahl` (ausführliche Notation) bzw. `punktzahl` (verkürzte Notation) zur Adressierung.

## Adressierung von Attributen

Attribute von Elementen werden in XPath als Attributknoten behandelt und entsprechend adressiert.

### Beispiel 1 (ausführliche Notation):

    <xsl:template match="./child::augen/attribute::farbe">
      <tr><td><b><xsl:text>Augenfarbe:</xsl:text></b></td>
      <td><xsl:value-of select="." /></td></tr>
    </xsl:template>

### Beispiel 2 (verkürzte Notation):

    <xsl:template match="augen/@farbe">
      <tr><td><b><xsl:text>Augenfarbe:</xsl:text></b></td>
      <td><xsl:value-of select="." /></td></tr>
    </xsl:template>

### Erläuterung:

Das Beispiel nimmt an, dass es eine XML-Notation `<augen farbe="...">` gibt. Für das Attribut wird ein eigenes Template definiert. Dabei wird im HTML-Ergebnisbaum eine zweispaltige Tabellenzeile erzeugt, in der links das statische Wort `Augenfarbe:` steht, während in der rechten Spalte der Wert des Attributs `farbe` ausgegeben wird. Das `match`-Attribut der Template-Definition wird so adressiert, dass das Template von einem Elternelement von `augen` aus - z.B. von `person` - aufgerufen werden kann. Der Pfad lautet dann in der ausführlichen Notation `./child::augen/attribute::farbe` und in der verkürzten, gebräuchlicheren Notation `augen/@farbe`. Bei der ausführlichen Notation kommen also die Achsenbezeichnungen `child::` (für Kindelement `child` aus Sicht von `person`) und `attribute::` für die Auswahl von dessen Attribut `farbe` zum Einsatz. In der verkürzten Notation genügt die relative Angabe des Kindelements `augen` und der Attributname, angeführt von einem Klammeraffen (`@`).

## Adressierung mit Wildcards

Die Adressierung mit Wildcards erlaubt es, mehrere Knoten auf einmal auszuwählen.

### Angenommene XML-Struktur:

    <dateicode>
     <signature>474946383961</signature>
     <screen-descriptor>10000200B30000</screen-descriptor>
     <color-map>000000BF000000BF00BFBF00</color-map>
     <extension-block>21F90401000000</extension-block>
     <!-- usw. -->
    </dateicode>

### Beispiel 1 (ausführliche Notation):

    <xsl:template match="dateicode">
     <xsl:value-of select="child::*" />
    </xsl:template>

### Beispiel 2 (verkürzte Notation):

    <xsl:template match="dateicode">
     <xsl:value-of select="*" />
    </xsl:template>

### Erläuterung:

Das Beispiel nimmt an, dass mit Hilfe von XML-Elementen der Aufbau einer Binärdatei (im Beispiel: GIF-Format) beschrieben wird. In der Ausgabe sollen die Inhalte aller Kindelemente von `dateicode` einfach in einem Rutsch geschrieben werden. In der Template-Definition zu `dateicode` wird dies im `select`-Attribut der xsl:value-of-Anweisung durch Angabe des Wildcard-Zeichens `*` (Sternzeichen) erreicht. In der ausführlichen Notation ist die Achsenbezeichnung `child::` angegeben, in der verkürzten Notation kann diese entfallen.

### Beachten Sie:

Das Wildcard-Zeichen `*` (Sternzeichen) wählt nur auf der nächstunteren Hierarchie-Ebene aus. Eine verschärfte Form ist die Zeichenfolge `//` (zwei Schrägstriche). Damit wird auf allen untergeordneten Hierarchie-Ebenen ausgewählt, egal, wie tief sich der Baum noch verzweigt.

## Adressierung mit Positionsangabe und Bedingungen

Durch absolute und relative Adressierung ist noch nicht jedes beliebige Element ansprechbar. Angenommen, ein Element namens `liste` hat 25 Kindelemente namens `listeneintrag`, dann greift eine Adressierung wie `liste/listeneintrag` nur auf das erste dieser Elemente zu. Solche Probleme lassen sich zwar auch durch xsl:for-each-Schleifen in den Griff bekommen, doch manchmal wird man auch nur ein bestimmtes der Kindelemente ansprechen wollen, und nicht alle der Reihe nach. Die folgenden Beispiele zeigen Adressierungen mit Positionsangaben und Bedingungen, um bestimmte einzelne Elemente zu adressieren. Dabei kommen zum Teil auch XPath-Funktionen zum Einsatz.

Syntax-Bestandteile in eckigen Klammern (`[]`) gehören ebenfalls zum Inventar der Adressierung mit Positionsangaben und Bedingungen. Solche Bestandteile werden als Prädikate bezeichnet. Viele der folgenden Beispiele verwenden solche Prädikate.

Beispiel | Notation | Erläuterung
--- | --- | ---
`self::liste` | ausführlich | adressiert das aktuelle Element, jedoch nur dann, wenn es vom Typ `liste` ist.
`child::listeneintrag[position() = 3]` | ausführlich | adressiert das 3. Kindelement vom Typ `listeneintrag` mit Hilfe der XPath-Funktion position().
`listeneintrag[3]` | verkürzt | adressiert das 3. Kindelement vom Typ `listeneintrag`.
`child::listeneintrag[position() = last()]` | ausführlich | adressiert das letzte Kindelement vom Typ `listeneintrag` mit Hilfe der XPath-Funktion last().
`listeneintrag[last()]` | verkürzt | adressiert das letzte Kindelement vom Typ `listeneintrag` mit Hilfe der XPath-Funktion last().
`listeneintrag[last()-1]` | verkürzt | adressiert das vorletzte Kindelement vom Typ `listeneintrag` mit Hilfe der XPath-Funktion last().
`/buch/kapitel[2]/abschnitt[4]/absatz[17]` | verkürzt | adressiert in einem Buch absolut den 17. Absatz des 4. Abschnitts im 2. Kapitel (entsprechende XML-Elementnamen vorausgesetzt).
`child::augen[attribute::farbe='blau']` | ausführlich | adressiert das Kindelement `augen`, jedoch nur dann, wenn es ein Attribut `farbe` mit dem Wert `blau` hat.
`augen[@farbe='blau']` | verkürzt | adressiert das Kindelement `augen`, jedoch nur dann, wenn es ein Attribut `farbe` mit dem Wert `blau` hat.
`child::augen[attribute::farbe and attribute::sehstaerke]` | ausführlich | adressiert das Kindelement `augen`, jedoch nur dann, wenn es sowohl ein Attribut `farbe` als auch ein Attribut `sehstaerke` hat (egal mit welchen zugewiesenen Werten).
`augen[@farbe and @sehstaerke]` | verkürzt | adressiert das Kindelement `augen`, jedoch nur dann, wenn es sowohl ein Attribut `farbe` als auch ein Attribut `sehstaerke` hat (egal mit welchen zugewiesenen Werten).
`/child::*[self::inhaltsverzeichnis or self::stichwortverzeichnis]` | ausführlich | adressiert in einem Buch absolut alle Kindelemente unterhalb der Wurzel, jedoch nur solche, die als Elementnamen `inhaltsverzeichnis` oder `stichwortverzeichnis` haben.
`.` | verkürzt | adressiert den aktuellen Knoten.
`..` | verkürzt | adressiert den Elternknoten des aktuellen Knotens.
`kapitel//absatz` | verkürzt | adressiert alle Elemente vom Typ `absatz`, die aus Sicht eines aktuellen Knotens unterhalb von Elementen vom Typ `kapitel` liegen. Die Syntax `//` wird auch als recursive descent operator bezeichnet. `//X` bezeichnet das gleiche wie `/descendant-or-self::node()/X`.
`buch//kapitel[position() < 5]` | verkürzt | adressiert die ersten vier Kindelemente des Typs `kapitel` innerhalb eines Elements vom Typ `buch`.

## XPath-Operatoren

XPath bietet eine Reihe von Operatoren an, die es erlauben, Werte zu vergleichen, Berechnungen durchzuführen, oder Ausdrücke zu bewerten. Solche Operatoren können in Attributen bestimmter XSLT-Elemente vorkommen. Dort helfen sie, Bedingungen zu formulieren, Elementpositionen zu berechnen und anderes mehr. XPath kennt folgende Operatoren:

Operator | Bedeutung
--- | ---
`+` | Addition
`-` | Subtraktion
`*` | Multiplikation - jedoch nur, wenn vor dem Operator keines der folgenden Zeichen bzw. keine der folgenden Zeichenfolgen steht: `@ :: ( [ ) ,`
`=` | gleich (Vergleich zweier Werte)
`!=` | ungleich (Vergleich zweier Werte)
`<` bzw. `&lt;` | kleiner als (Vergleich zweier Werte). Maskierung innerhalb von XSLT erforderlich.
`>` bzw. `&gt;` | größer als (Vergleich zweier Werte). Maskierung innerhalb von XSLT zu empfehlen.
`<=` bzw. `&lt;=` | kleiner als oder gleich (Vergleich zweier Werte). Maskierung innerhalb von XSLT erforderlich.
`>=` bzw. `&gt;=` | größer als oder gleich (Vergleich zweier Werte). Maskierung innerhalb von XSLT zu empfehlen.
`and` | logische Und-Verknüpfung (beide Ausdrücke)
`or` | logische Oder-Verknüpfung (einer von beiden Ausdrücken)
`div` | Fließkommateilung
`mod` | Rest der Fließkommateilung

| XPath-Funktionen
| XSLT-Elemente

© 2007 Impressum