XPath 3.0, XPath 2.0, XPath 1.0 / XPath Funktionen

XPath Funktionen

XPath Funktionen

XPath 3.0 und XPath 3.1 bieten mehrere Hundert verschiedene Standard-Funktionen. Ein Teil davon steht bereits seit XPath 1.0 bzw. XPath 2.0 zur Verfügung.

XPath Funktionen

In XPath 3.0 und XPath 3.1 stehen nach meiner Recherche mehrere Hundert unterschiedliche Funktionen zur Verfügung, die teilweise mehrere Signaturen besitzen bzw. diversen Namespaces zugeordnet sind. Zählen wir diese unterschiedlichen Ausprägungen hinzu, so liegt die Gesamtzahl verfügbarer Standard-Funktionen über 300. Ein geringer Anteil davon steht bereits seit XPath 1.0 bereit, in XPath 2.0 kamen noch einige hinzu.

Die Flexibilität vieler Standard-Funktionen wird nochmals erhöht durch den zusätzlichen Einsatz individuell programmierbarer (oft anonymer) Funktionen, die keinen Namen haben müssen, sondern mit ihren Parametern und internen Logiken direkt im Aufruf der Hauptfunktion implementiert werden.

Speziell bei Verwendung unterschiedlicher XSL-Prozessoren in den Entwicklungs-, Test- und Live-Systemen ist es sinnvoll, einem evtl. unterschiedlichen Verhalten der Prozessoren bei diversen Funktionsaufrufen nachzugehen. Wie bei diversen Editoren, kann nicht ausgeschlossen werden, daß nicht alle Funktionen überhaupt bzw. einheitlich implementiert sind.

Die Standardfunktionen werden hauptsächlich folgenden Namespaces zugeordnet:

Gibt den Absolutwert einer Zahl zurück. Parameter: xs:numeric. Rückgabetyp: xs:numeric. abs(-38)" ergibt den Wert 38. Die Funktion steht erst ab 2.0 zur Verfügung. Signatur: abs(xs:numeric?) as xs:numeric?.
Gibt den Arkus-Cosinus eines Wertes zurück. Signatur: acos(xs:double?) as xs:double?.
"fn:adjust-date-to-timezone" fügt einem xs:date noch die Zeitzone hinzu, die sich aus dem Kontext ergibt. Signatur: adjust-date-to-timezone(xs:date?) as xs:date?. Alternative Signatur: adjust-date-to-timezone(xs:date?, xs:dayTimeDuration?) as xs:date?.
"fn:adjust-dateTime-to-timezone" fügt einem xs:dateTime noch die Zeitzone hinzu, die sich aus dem Kontext ergibt. Signatur: adjust-dateTime-to-timezone(xs:dateTime?) as xs:dateTime?. Alternative Signatur: adjust-dateTime-to-timezone(xs:dateTime?, xs:dayTimeDuration?) as xs:dateTime?.
"fn:adjust-time-to-timezone" fügt einem xs:time noch die Zeitzone hinzu, die sich aus dem Kontext ergibt. Signatur: adjust-time-to-timezone(xs:time?) as xs:time?. Alternative Signatur: adjust-time-to-timezone(xs:time?, xs:dayTimeDuration?) as xs:time?.
generiert ein "analyze-string-result"-Element mit den Childnodes "match" bzw. "non-match". Signatur: analyze-string(xs:string?, xs:string) as element(fn:analyze-string-result). Alternative Signatur: analyze-string(xs:string?, xs:string, xs:string) as element(fn:analyze-string-result).
append fügt einem bestehenden Array ein weiteres Feld hinzu. Signatur: append(array(*), item()*) as array(*).
Gibt den Arkus-Sinus eines Wertes zurück. Signatur: asin(xs:double?) as xs:double?.
Gibt den Arkus-Tangens eines Wertes zurück. Signatur: atan(xs:double?) as xs:double?.
available-environment-variables gibt eine Liste der Umgebungsvariablen zurück. Signatur: available-environment-variables() as xs:string*.
available-system-properties gibt eine Liste von Systemproperties zurück, die dann über system-property ausgewertet werden können. Signatur: available-system-properties() as xs:QName*.
berechnet den Durchschnitt mehrerer Zahlenwerte. Signatur: avg(xs:anyAtomicType*) as xs:anyAtomicType?.
rundet einen Zahlenwert auf zur nächstgrößren Zahl: ceiling(4.1) > 5 Signatur: ceiling(xs:numeric?) as xs:numeric?.
codepoint-equal vergleicht zwei Strings auf der Codepoint-Ebene. Signatur: codepoint-equal(xs:string?, xs:string?) as xs:boolean?.
codepoints-to-string konvertiert eine Liste von Codepoints in einen String. Signatur: codepoints-to-string(xs:integer*) as xs:string.
Spricht eine Collection externer XML-Dokumente an, die als Input verarbeitet werden können. Signatur: collection() as item()*. Alternative Signatur: collection(xs:string?) as item()*.
"compare" vergleicht zwei Stringparameter miteinander Signatur: compare(xs:string?, xs:string?) as xs:integer?. Alternative Signatur: compare(xs:string?, xs:string?, xs:string) as xs:integer?.
Die "concat"-Funktion verkettet mehrere Informationen zu einem String. Signatur: concat(xs:anyAtomicType?, xs:anyAtomicType?, xs:anyAtomicType?) as xs:string.
Die "contains"-Funktion prüft, ob in einem String ein bestimmter Teilstring enthalten ist. Signatur: contains(xs:string?, xs:string?) as xs:boolean. Alternative Signatur: contains(xs:string?, xs:string?, xs:string) as xs:boolean.
map:contains prüft, ob eine map einen bestimmten Schlüssel aufweist. Signatur: contains(map(*), xs:anyAtomicType) as xs:boolean.
contains-token prüft, ob die gegebenen Zeichenkette einem Token entspricht, ggf. unter den Regeln der Collation Signatur: contains-token(xs:string*, xs:string) as xs:boolean. Alternative Signatur: contains-token(xs:string*, xs:string, xs:string) as xs:boolean.
copy-of liefert eine tiefe Kopie einer Sequenz zurück. Signatur: copy-of() as item(). Alternative Signatur: copy-of(item()*) as item()*.
Gibt den Cosinus eines Wertes zurück. Signatur: cos(xs:double?) as xs:double?.
zählt eine Anzahl Items in einer Sequenz Signatur: count(item()*) as xs:integer.
current gibt den aktuellen Node zurück Signatur: current() as item().
gibt das aktuelle Datum zurück (mit Zeitzone) Signatur: current-date() as xs:date.
gibt das aktuelle Datum und Zeit zurück (mit Zeitzone) Signatur: current-dateTime() as xs:dateTimeStamp.
Gibt die aktuelle Gruppierung zurück, die durch Aufruf von xsl:for-each-group entstanden ist.. Signatur: current-group() as item()*.
Gibt den Gruppierungsschlüssel aus xsl:for-each-group zurück. Signatur: current-grouping-key() as xs:anyAtomicType*.
Gibt Itemgruppe zurück, die durch xsl:merge generiertwird. Signatur: current-merge-group() as item()*. Alternative Signatur: current-merge-group(xs:string) as item()*.
Gibt den Gruppierungsschlüssel jener Itemgruppe zurück, die durch xsl:merge generiertwird. Signatur: current-merge-key() as xs:anyAtomicType*.
gibt die aktuelle Zeit zurück. Signatur: current-time() as xs:time.
Die data() Funktion liefert die atomisierten Werte einer Sequenz: jeder Node wird durch seinen Wert ersetzt. Signatur: data() as xs:anyAtomicType*. Alternative Signatur: data(item()*) as xs:anyAtomicType*.
Gibt die xs:dateTime zurück. Signatur: dateTime(xs:date?, xs:time?) as xs:dateTime?.
Gibt den Tag von xs:date zurück. Signatur: day-from-date(xs:date?) as xs:integer?.
Gibt den Tag von xs:dateTime zurück. Signatur: day-from-dateTime(xs:dateTime?) as xs:integer?.
Gibt die Anzahl der Tage in einer xs:duration zurück. Signatur: days-from-duration(xs:duration?) as xs:integer?.
Prüft, ob zwei Sequenzen gleich sind. Signatur: deep-equal(item()*, item()*) as xs:boolean. Alternative Signatur: deep-equal(item()*, item()*, xs:string) as xs:boolean.
default-language Gibt die Default-Language zurück. Signatur: default-language() as xs:language.
Gibt eine Liste von Werten zurück, ohne doppelte Werte. Siehe xsl:for-each-group. Signatur: distinct-values(xs:anyAtomicType*) as xs:anyAtomicType*. Alternative Signatur: distinct-values(xs:anyAtomicType*, xs:string) as xs:anyAtomicType*.
liest ein externes XML-Dokument ein. Signatur: document(item()*) as node()*. Alternative Signatur: document(item()*, node()) as node()*.
"empty" überprüft, ob eine Sequenz leer ist, und gibt einen Booleanwert zurück. Signatur: empty(item()*) as xs:boolean.
prüft, ob ein Item (das als String gecastet werden kann) mit einer bestimmten Zeichenfolge endet. Signatur: ends-with(xs:string?, xs:string?) as xs:boolean. Alternative Signatur: ends-with(xs:string?, xs:string?, xs:string) as xs:boolean.
map:entry generiert eine Map mit einem einzelnen Schlüssel-Wert-Paar. Signatur: entry(xs:anyAtomicType, item()*) as map(*).
environment-variable gibt den Wert einer Umgebungsvariablen zurück. Signatur: environment-variable(xs:string) as xs:string?.
Die "exactly-one"-Funktion erzwingt, daß eine Sequence genau ein einziges Item aufweist. Signatur: exactly-one(item()*) as item().
Prüft, ob das Argument existiert, also ob die Sequenz leer ist. Signatur: exists(item()*) as xs:boolean.
false Gibt xs:boolean zurück. Signatur: false() as xs:boolean.
"filter" gibt jene Items einer Sequenz zurück, die in der anonymen Funktion ein true() ergeben Signatur: filter(item()*, function(item()) as xs:boolean) as item()*.
array:filter generiert ein Array mit allen Einträgen, für die die Funktion true() zurückgibt. Signatur: filter(array(*), function(item()*) as xs:boolean) as array(*).
map:find sucht in einer Sequenz bzw. Map array nach Map-Entries, die den gesuchten Schlüssel beinhalten, und geben die jeweiligen Werte zurück. Signatur: find(item()*, xs:anyAtomicType) as array(*).
rundet einen Zahlenwert zur kleineren ganzen Zahl ab. floor(5.9) > 5 Signatur: floor(xs:numeric?) as xs:numeric?.
verarbeitet alle Items einer Sequenz von links nach rechts; das Ergebnis wird kumuliert. Signatur: fold-left(item()*, item()*, function(item()*, item()) as item()*) as item()*.
verarbeitet alle Items einer Sequenz von rechts nach links. Signatur: fold-right(item()*, item()*, function(item(), item()*) as item()*) as item()*.
fn:for-each fordert zwei Parameter ein: a) ein oder mehrere Items als Sequenz, b) eine Funktion, die für jedes Item dieser Sequenz aufgerufen wird. Signatur: for-each(item()*, function(item()) as item()*) as item()*.
array:for-each übernimmt ein Array als Parameter und gibt ein anderes Array desselben Umfanges zurück. Jeder einzelne Wert wird durch eine zu implementierende Funktion modifiziert. Signatur: for-each(array(*), function(item()*) as item()*) as array(*).
map:for-each benötigt eine Funktion, die jedes map:entry in eine Sequenz verkettet. Signatur: for-each(map(*), function(xs:anyAtomicType, item()*) as item()*) as item()*.
fn:for-each-pair bildet Kombinationen aus zwei Sequenzen, die dieselbe Anzahl Items haben müssen. Signatur: for-each-pair(item()*, item()*, function(item(), item()) as item()*) as item()*.
array:for-each-pair gibt ein Array zurück, das seine Einzelwerte aus jedem Member-Paar an derselben Position bezieht. Zur Berechnung des Ergebnisses wird eine Funktion definiert. Signatur: for-each-pair(array(*), array(*), function(item()*, item()*) as item()*) as array(*).
formatiert einen date-Wert. Signatur: format-date(xs:date?, xs:string) as xs:string?. Alternative Signatur: format-date(xs:date?, xs:string, xs:string?, xs:string?, xs:string?) as xs:string?.
formatiert einen dateTime-Wert Signatur: format-dateTime(xs:dateTime?, xs:string) as xs:string?. Alternative Signatur: format-dateTime(xs:dateTime?, xs:string, xs:string?, xs:string?, xs:string?) as xs:string?.
format-integer formatiert einen xs:integer. Signatur: format-integer(xs:integer?, xs:string) as xs:string. Alternative Signatur: format-integer(xs:integer?, xs:string, xs:string?) as xs:string.
formatiert eine Zahl nach einem vozugebendem Muster. Wird häufig in Kombination mit xsl:decimal-format verwendet. Signatur: format-number(xs:numeric?, xs:string) as xs:string. Alternative Signatur: format-number(xs:numeric?, xs:string, xs:string?) as xs:string.
Formatiert xs:time. Signatur: format-time(xs:time?, xs:string) as xs:string?. Alternative Signatur: format-time(xs:time?, xs:string, xs:string?, xs:string?, xs:string?) as xs:string?.
generate-id generiert eine id. Signatur: generate-id() as xs:string. Alternative Signatur: generate-id(node()?) as xs:string.
array:get liefert jenen Wert in einem Array, der an einer bestimmten Indexstelle steht (gezählt wird von 1 an). Signatur: get(array(*), xs:integer) as item()*.
map:get gibt den Wert zurück, der einem Schlüssel zugeordnet ist. Ist der Schlüssel nicht vorhanden, gibt map:get eine leere Sequenz zurück. Signatur: get(map(*), xs:anyAtomicType) as item()*.
has-children Prüft, ob ein Node Childnodes besitzt. Signatur: has-children() as xs:boolean. Alternative Signatur: has-children(node()?) as xs:boolean.
Gibt das erste Item in einer Sequenz zurück. Signatur: head(item()*) as item()?.
array:head gibt das erste Item des Arrays zurück. Signatur: head(array(*)) as item()*.
Gibt die Stunde von xs:dateTime zurück. Signatur: hours-from-dateTime(xs:dateTime?) as xs:integer?.
Gibt die Anzahl der Stunden in einer xs:duration zurück. Signatur: hours-from-duration(xs:duration?) as xs:integer?.
Gibt die Stunde von xs:time zurück. Signatur: hours-from-time(xs:time?) as xs:integer?.
Gibt die implizite Zeitzone aus dem Kontext zurück Signatur: implicit-timezone() as xs:dayTimeDuration.
Die in-scope-prefixes gibt eine Liste aller Namespace-prefixe, die im Kontext verwendet werden. Signatur: in-scope-prefixes(element()) as xs:string*.
Position eines ausgewählten Items in einer Sequenz. Signatur: index-of(xs:anyAtomicType*, xs:anyAtomicType) as xs:integer*. Alternative Signatur: index-of(xs:anyAtomicType*, xs:anyAtomicType, xs:string) as xs:integer*.
Die "insert-before"-Funktion fügt ab einer bestimmten Position zusätzliche Items in eine ursprüngliche Sequenz ein, so daß im Ergebnis eine neue Sequenz entsteht. Signatur: insert-before(item()*, xs:integer, item()*) as item()*.
array:insert-before erlaubt, an einer bestimmten Position ein zusätzlichen Wert einzufügen. Signatur: insert-before(array(*), xs:integer, item()*) as array(*).
array:join verkettet den Inhalt diverser Arrays in ein einzelnes Array. Signatur: join(array(*)*) as array(*).
json-doc liest eine externe Datei aus und gibt das Ergebnis als JSON zurück. Signatur: json-doc(xs:string?) as item()?. Alternative Signatur: json-doc(xs:string?, map(*)) as item()?.
konvertiert JSON-Daten in XML-Dokument. Signatur: json-to-xml(xs:string) as document-node(). Alternative Signatur: json-to-xml(xs:string, map(*)) as document-node().
map:keys gibt eine Sequenz aller Schlüsselwerte zurück.> Signatur: keys(map(*)) as xs:anyAtomicType*.
Gibt die Position des letzten Kontextnodes zurück. Signatur: last() as xs:integer.
Gibt den lokalen Namen eines Nodes zurück. Im Unterschied zu fn:name() ohne Namespace-Information. Signatur: local-name() as xs:string. Alternative Signatur: local-name(node()?) as xs:string.
Gibt den natürlichen Logarithmus eines Wertes zurück. Signatur: log(xs:double?) as xs:double?.
Gibt den 10er-Logarithmus eines Wertes zurück. Signatur: log10(xs:double?) as xs:double?.
konvertiert jeden Großbuchstaben eines Strings in den entsprechenden Kleinbuchstaben Signatur: lower-case(xs:string?) as xs:string.
prüft, ob ein String einem regulären Ausdruck entspricht Signatur: matches(xs:string?, xs:string) as xs:boolean. Alternative Signatur: matches(xs:string?, xs:string, xs:string) as xs:boolean.
gibt den Maximalwert mehrerer Zahlenwerte zurück. Signatur: max(xs:anyAtomicType*) as xs:anyAtomicType?. Alternative Signatur: max(xs:anyAtomicType*, xs:string) as xs:anyAtomicType?.
map:merge kombiniert die Inhalte mehrerer Maps in eine neue Map, die wiederum ausgewertet werden kann. Signatur: merge(map(*)*) as map(*). Alternative Signatur: merge(map(*)*, map(*)) as map(*).
gibt den Minimalwert mehrerer Zahlenwerte zurück. Signatur: min(xs:anyAtomicType*) as xs:anyAtomicType?. Alternative Signatur: min(xs:anyAtomicType*, xs:string) as xs:anyAtomicType?.
Gibt die Minute von xs:dateTime zurück. Signatur: minutes-from-dateTime(xs:dateTime?) as xs:integer?.
Gibt die Anzahl der Minuten in einer xs:duration zurück. Signatur: minutes-from-duration(xs:duration?) as xs:integer?.
Gibt die Minute von xs:time zurück. Signatur: minutes-from-time(xs:time?) as xs:integer?.
Gibt den Monat von xs:date zurück. Signatur: month-from-date(xs:date?) as xs:integer?.
Gibt den Monat von xs:dateTime zurück. Signatur: month-from-dateTime(xs:dateTime?) as xs:integer?.
Gibt die Anzahl der Monate in einer xs:duration zurück. Signatur: months-from-duration(xs:duration?) as xs:integer?.
name gibt den Namen eines Nodes als xs:string zurück, ggf. einschließlich Namespace. Signatur: name() as xs:string. Alternative Signatur: name(node()?) as xs:string.
node-name Gibt den Node-Name als xs:QName zurück. Signatur: node-name() as xs:QName?. Alternative Signatur: node-name(node()?) as xs:QName?.
löscht führende und schließende Leerzeichen in einem String. Signatur: normalize-space() as xs:string. Alternative Signatur: normalize-space(xs:string?) as xs:string.
normalize-unicode führt die Unicode-Normalisierung eines xs:string-Parameters durch. Signatur: normalize-unicode(xs:string?) as xs:string. Alternative Signatur: normalize-unicode(xs:string?, xs:string) as xs:string.
not Gibt false zurück, wenn der Parameter true ist; gibt true zurück, wenn der Parameter false ist. Signatur: not(item()*) as xs:boolean.
konvertiert einen String in eine Zahl. Beispiel: number('9.95'): 9.95. number('hallo'): NaN. Signatur: number() as xs:double. Alternative Signatur: number(xs:anyAtomicType?) as xs:double.
Die Funktion "one-or-more" überprüft, ob eine Sequence überhaupt Inhalte hat: mindestens ein Item muß vorhanden sein. Signatur: one-or-more(item()*) as item()+.
Parst einen JSON-String. Signatur: parse-json(xs:string?) as item()?. Alternative Signatur: parse-json(xs:string?, map(*)) as item()?.
parse-xml-fragment konvertiert ein XML Dokument, das in einem String vorliegt, und gibt den Root-Document-Node zurück. Signatur: parse-xml-fragment(xs:string?) as document-node()?.
Gibt den XPath-Pfad eines Nodes zurück. Signatur: path() as xs:string?. Alternative Signatur: path(node()?) as xs:string?.
Liefert eine Annährung an die Zahl PI: 3,14 ... Signatur: pi() as xs:double.
Nummer des aktuellen Items in der Sequenz. Signatur: position() as xs:integer.
array:put gibt ein Array zurück, das alle bisherigen Felder beinhaltet, ausgenommen jenes, dessen Wert mit put verändert wurde. Signatur: put(array(*), xs:integer, item()*) as array(*).
map:put generiert eine Map, die alle Inhalte der ursprünglichen Map enthält, aber mit einem zusätzlichen Eintrag, der die Inhalte für eventuelle identische Schlüssel ersetzt. Signatur: put(map(*), xs:anyAtomicType, item()*) as map(*).
random-number-generator generiert eine map, deren Schlüssel ein xs:string ist: die zulässigen Werte dieses Schlüssels sind "number", "next" und "permute". Signatur: random-number-generator() as map(xs:string, item()). Alternative Signatur: random-number-generator(xs:anyAtomicType?) as map(xs:string, item()).
gibt einen String zurück, der durch einen regulären Ausdruck im Rahmen von xsl:analyze-string ermittelt wird. Signatur: regex-group(xs:integer) as xs:string.
Die "remove"-Funktion löscht bestimmte Items (die sich aus ihrer Indexposition ergeben) aus einer Sequence. Signatur: remove(item()*, xs:integer) as item()*.
array:remove ist in der Lage, aus einem Array jenes Feld zu entfernen, das über den Positions-Parameter bestimmt wird Signatur: remove(array(*), xs:integer*) as array(*).
map:remove generiert eine Map, in der alle Inhalte der ursprünglichen Map enthalten sind, jedoch ohne jenen Schlüssel, der mit "remove" entfernt wurde. Signatur: remove(map(*), xs:anyAtomicType*) as map(*).
Ersetzt einen String durch eine andere Zeichenkette. Signatur: replace(xs:string?, xs:string, xs:string) as xs:string. Alternative Signatur: replace(xs:string?, xs:string, xs:string, xs:string) as xs:string.
Die "reverse"-funktion kehrt die Reihenfolge der Items in einer Sequence um. Signatur: reverse(item()*) as item()*.
array:reverse gibt ein Array zurück, dessen Items in umgekehrter Reihenfolge angeordnet sind. Signatur: reverse(array(*)) as array(*).
rundet eine Dezimalzahl zum nächsten ganzen Zahl. Signatur: round(xs:numeric?) as xs:numeric?. Alternative Signatur: round(xs:numeric?, xs:integer) as xs:numeric?.
wie round; Sonderfall: der Originalwert ist x.5, dann rundet round-half-to-even zu jenem Integerwert in nächster Umgebung, der eine gerade Zahl darstellt. Signatur: round-half-to-even(xs:numeric?) as xs:numeric?. Alternative Signatur: round-half-to-even(xs:numeric?, xs:integer) as xs:numeric?.
Gibt die Sekunden von xs:dateTime zurück. Signatur: seconds-from-dateTime(xs:dateTime?) as xs:decimal?.
Gibt die Anzahl der Sekunden in einer xs:duration zurück. Signatur: seconds-from-duration(xs:duration?) as xs:decimal?.
Gibt die Sekunden von xs:time zurück. Signatur: seconds-from-time(xs:time?) as xs:decimal?.
"serialize" konvertiert eine Sequenz in einen String. Signatur: serialize(item()*) as xs:string. Alternative Signatur: serialize(item()*, item()?) as xs:string.
Gibt den Sinus eines Wertes zurück. Signatur: sin(xs:double?) as xs:double?.
array:size ermittelt die Größe des Arrays Signatur: size(array(*)) as xs:integer.
map:size gibt die Anzahl der Map-Entries zurück. Signatur: size(map(*)) as xs:integer.
generiert eine tiefe Kopie einer Sequenz, mit allen Elementen und Attributen. Signatur: snapshot() as item(). Alternative Signatur: snapshot(item()*) as item()*.
Sortiert eine Sequenz, basiert ggf. auf einer Funktion als Sortierungsschlüssel. Signatur: sort(item()*) as item()*. Alternative Signatur: sort(item()*, xs:string?) as item()*. Alternative Signatur: sort(item()*, xs:string?, function(item()) as xs:anyAtomicType*) as item()*.
array:sort generiert ein Array, das alle Items des ursprünglichen Arrays beinhaltet, jedoch in sortierter Reihenfolge. Signatur: sort(array(*)) as array(*). Alternative Signatur: sort(array(*), xs:string?) as array(*). Alternative Signatur: sort(array(*), xs:string?, function(item()*) as xs:anyAtomicType*) as array(*).
Gibt die Quadratwurzel eines Wertes zurück. math:sqrt(2) ergibt den Wert 1.4142135623731. Signatur: sqrt(xs:double?) as xs:double?.
prüft, ob ein Item (das als String gecastet werden kann) mit einer bestimmten Zeichenfolge beginnt. Signatur: starts-with(xs:string?, xs:string?) as xs:boolean. Alternative Signatur: starts-with(xs:string?, xs:string?, xs:string) as xs:boolean.
konvertiert z.B. einen Textnode in eine Zeichenkette. Signatur: string() as xs:string. Alternative Signatur: string(item()?) as xs:string.
konvertiert eine Sequenz in eine Zeichenkette, mit Trennzeichen. Signatur: string-join(xs:anyAtomicType*) as xs:string. Alternative Signatur: string-join(xs:anyAtomicType*, xs:string) as xs:string.
ermittelt die Länge einer Zeichenkette. Signatur: string-length() as xs:integer. Alternative Signatur: string-length(xs:string?) as xs:integer.
string-to-codepoints konvertiert einen String in Codepoints. Signatur: string-to-codepoints(xs:string?) as xs:integer*.
array:subarray errechnet ein Teil-Array, das mit der gewünschten Start-Position beginnt und alle restlichen Felder übernimmt. Signatur: subarray(array(*), xs:integer) as array(*). Alternative Signatur: subarray(array(*), xs:integer, xs:integer) as array(*).
Die "subsequence"-Funktion kann aus einer Sequenz einzelne Teile filtern, die sich über die Position und die Anzahl der Items definiert. Die Position eines Items läßt sich (sofern nicht bekannt) über die "index-of"-Funktion ermitteln. Signatur: subsequence(item()*, xs:double) as item()*. Alternative Signatur: subsequence(item()*, xs:double, xs:double) as item()*.
bildet Teilstrings aus einer längeren Zeichenkette. Signatur: substring(xs:string?, xs:double) as xs:string. Alternative Signatur: substring(xs:string?, xs:double, xs:double) as xs:string.
liefert aus einem gegebenen String jenen Teil, der nach dem Auftreten eines zweiten Parameters liegt. Signatur: substring-after(xs:string?, xs:string?) as xs:string. Alternative Signatur: substring-after(xs:string?, xs:string?, xs:string) as xs:string.
liefert aus einem gegebenen String jenen Teil, der vor dem Auftreten eines zweiten Parameters liegt. Signatur: substring-before(xs:string?, xs:string?) as xs:string. Alternative Signatur: substring-before(xs:string?, xs:string?, xs:string) as xs:string.
summiert eine Liste von Zahlen. Signatur: sum(xs:anyAtomicType*) as xs:anyAtomicType. Alternative Signatur: sum(xs:anyAtomicType*, xs:anyAtomicType?) as xs:anyAtomicType?.
Gibt den Wert eines Systemproperties zurück. Vgl. available-system-properties. Signatur: system-property(xs:string) as xs:string.
gibt alle Items einer Sequenz zurück, ausgenommen das erste. Vgl. fn:head. Signatur: tail(item()*) as item()*.
array:tail gibt ab dem zweiten Item alle Folge-Items zurück. Signatur: tail(array(*)) as array(*).
Gibt den Tangens eines Wertes zurück. Signatur: tan(xs:double?) as xs:double?.
Gibt die Zeitzone von xs:date zurück. Signatur: timezone-from-date(xs:date?) as xs:dayTimeDuration?.
Gibt die Zeitzone von xs:dateTime zurück. Signatur: timezone-from-dateTime(xs:dateTime?) as xs:dayTimeDuration?.
Gibt die Zeitzone von xs:time zurück. Signatur: timezone-from-time(xs:time?) as xs:dayTimeDuration?.
splittet eine Zeichenkette in eine Sequenz, basierend auf einem Trennzeichen. Signatur: tokenize(xs:string?) as xs:string*. Alternative Signatur: tokenize(xs:string?, xs:string) as xs:string*. Alternative Signatur: tokenize(xs:string?, xs:string, xs:string) as xs:string*.
Startet eine XSL-Transformation mit einem dynamisch geladenen XSL-Stylesheet. Signatur: transform(map(*)) as map(*).
ersetzt jedes Zeichen, das bei einer Zeichenkette in einer Parameterliste steht, durch ein anderes Zeichen Signatur: translate(xs:string?, xs:string, xs:string) as xs:string.
true Gibt den xs:boolean-Wert true() zurück. Signatur: true() as xs:boolean.
liest eine externe Nicht-XML-Datei in eine String-Sequenz. Signatur: unparsed-text(xs:string?) as xs:string?. Alternative Signatur: unparsed-text(xs:string?, xs:string) as xs:string?.
unparsed-text-available Prüft, ob eine Nicht-XML-Datei vorhanden ist, gibt xs:boolean zurück. Signatur: unparsed-text-available(xs:string?) as xs:boolean. Alternative Signatur: unparsed-text-available(xs:string?, xs:string) as xs:boolean.
liest eine externe Nicht-XML-Datei zeilenweise in eine String-Sequenz. Signatur: unparsed-text-lines(xs:string?) as xs:string*. Alternative Signatur: unparsed-text-lines(xs:string?, xs:string) as xs:string*.
konvertiert jeden Kleinbuchstaben eines Strings in den entsprechenden Großbuchstaben Signatur: upper-case(xs:string?) as xs:string.
konvertiert ein XML-Dokument (mit entsprechender Struktur) in einen JSON-String. Signatur: xml-to-json(node()?) as xs:string?. Alternative Signatur: xml-to-json(node()?, map(*)) as xs:string?.
Gibt das Jahr aus xs:date zurück. Signatur: year-from-date(xs:date?) as xs:integer?.
Gibt das Jahr aus xs:dateTime zurück. Signatur: year-from-dateTime(xs:dateTime?) as xs:integer?.
Gibt die Anzahl der Jahre aus einer xs:duration zurück. Signatur: years-from-duration(xs:duration?) as xs:integer?.
Die zero-or-one-Funktion stellt sicher, daß eine Sequence maximal ein Item haben darf; die Sequence kann auch leer sein. Signatur: zero-or-one(item()*) as item()?.

wg / 19. Januar 2018



Fragen? Anmerkungen? Tips?

Bitte nehmen Sie Kontakt zu mir auf:

Vorname
Nachname
Mailadresse





Zahlenfunktionen

Zahlen - Rundungsfunktionen

Zeit ist Geld

Toll, ein Kalender

Zeitkalkulation in Java

Stringfunktionen

Codepoints

XPath: compare

XPath: concat

XPath: contains

XPath ends-with

XPath: lower-case

Reguläre Ausdrücke

XPath: matches

xsl:analyze-string

Reguläre Ausdrücke in Java

Reguläre Ausdrücke in C#.NET

XPath: normalize-space

XPath: starts-with

string oder xs:string?

XPath: string-join

substring, string-length

XPath: substring-after

XPath: substring-before

XPath: tokenize

XPath: translate

XPath: upper-case

XPath: Sequence - Funktionen

XPath: data

XPath: distinct-values

XPath: exactly-one

XPath: zero-or-one

XPath: one-or-more

XPath Sequences: concat, union, except, intersect

XPath deep-equal

XPath: Der Vergleich von leeren Sequences mit leeren Strings

XPath: empty

XPath: exists

XPath: filter

XPath: for-each

XPath: for-each-pair

XPath: fold-left

XPath: fold-right

head, tail, snapshot

XPath: index-of(), position(), last()

XPath in-scope-prefixes

XPath: insert-before

XPath: remove

XPath: reverse

XPath: subsequence

XPath 3.0: path

XPath serialize

Anonyme Funktionen

unparsed-text-lines: CSV in XML konvertieren

JSON

XPath json-to-xml, xml-to-json

XPath: fn:parse-json

XPath: fn:json-doc

XPath 3.1: Map, xsl:map

XPath: transform

XPath 3.1: Array

available-environment-variables()

system-properties



Vielen Dank für Ihr Interesse an meiner Arbeit.


V.i.S.d.P.: Wilfried Grupe * Klus 6 * 37643 Negenborn

☎ 0151. 750 360 61 * eMail: info2018@wilfried-grupe.de

www.wilfried-grupe.de/XPath_30_Funktionen.html