Home
Über mich
Veröffentlichungen

XML XML-Schema XPath XSL-T XSL-FO XQuery XProc SVG

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

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. 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 ist es möglich, dass nicht alle Funktionen überhaupt bzw. einheitlich implementiert sind.

Die Standardfunktionen werden hauptsächlich folgenden Namespaces zugeordnet:

abs 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?.
acos gibt den Arkus-Cosinus eines Wertes zurück. Signatur: acos(xs:double?) as xs:double?.
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?.
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?.
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?.
analyze-string 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(*).
asin gibt den Arkus-Sinus eines Wertes zurück. Signatur: asin(xs:double?) as xs:double?.
atan 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*.
avg berechnet den Durchschnitt mehrerer Zahlenwerte. Signatur: avg(xs:anyAtomicType*) as xs:anyAtomicType?.
ceiling rundet einen Zahlenwert auf zur nächstgrößeren 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.
collection 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?.
concat verkettet mehrere Informationen zu einem String. Signatur: concat(xs:anyAtomicType?, xs:anyAtomicType?, xs:anyAtomicType?) as xs:string.
contains 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.
contains 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()*.
cos gibt den Cosinus eines Wertes zurück. Signatur: cos(xs:double?) as xs:double?.
count 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().
current-date gibt das aktuelle Datum zurück (mit Zeitzone) Signatur: current-date() as xs:date.
current-dateTime gibt das aktuelle Datum und Zeit zurück (mit Zeitzone) Signatur: current-dateTime() as xs:dateTimeStamp.
current-group gibt die aktuelle Gruppierung zurück, die durch Aufruf von xsl:for-each-group entstanden ist. Signatur: current-group() as item()*.
current-grouping-key gibt den Gruppierungsschlüssel aus xsl:for-each-group zurück. Signatur: current-grouping-key() as xs:anyAtomicType*.
current-merge-group gibt eine Itemgruppe zurück, die durch xsl:merge generiertwird. Signatur: current-merge-group() as item()*. Alternative Signatur: current-merge-group(xs:string) as item()*.
current-merge-key gibt den Gruppierungsschlüssel jener Itemgruppe zurück, die durch xsl:merge generiertwird. Signatur: current-merge-key() as xs:anyAtomicType*.
current-time gibt die aktuelle Zeit zurück. Signatur: current-time() as xs:time.
data 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*.
dateTime gibt die xs:dateTime zurück. Signatur: dateTime(xs:date?, xs:time?) as xs:dateTime?.
day-from-date gibt den Tag von xs:date zurück. Signatur: day-from-date(xs:date?) as xs:integer?.
day-from-dateTime gibt den Tag von xs:dateTime zurück. Signatur: day-from-dateTime(xs:dateTime?) as xs:integer?.
days-from-duration gibt die Anzahl der Tage in einer xs:duration zurück. Signatur: days-from-duration(xs:duration?) as xs:integer?.
deep-equal 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.
distinct-values 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*.
document 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.
ends-with 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.
entry 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?.
exactly-one erzwingt, dass eine Sequenz genau ein einziges Item aufweist. Signatur: exactly-one(item()*) as item().
exists 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()*.
filter 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(*).
find 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(*).
floor rundet einen Zahlenwert zur kleineren ganzen Zahl ab. floor(5.9) > 5 Signatur: floor(xs:numeric?) as xs:numeric?.
fold-left 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()*.
fold-right verarbeitet alle Items einer Sequenz von rechts nach links. Signatur: fold-right(item()*, item()*, function(item(), item()*) as item()*) as item()*.
for-each 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()*.
for-each array:for-each übernimmt ein Array als Parameter und gibt ein anderes Array desselben Umfangs zurück. Jeder einzelne Wert wird durch eine zu implementierende Funktion modifiziert. Signatur: for-each(array(*), function(item()*) as item()*) as array(*).
for-each 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()*.
for-each-pair 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()*.
for-each-pair 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(*).
format-date 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?.
format-dateTime 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.
format-number formatiert eine Zahl nach einem vozugebenden 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.
format-time 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.
get 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()*.
get 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.
head gibt das erste Item in einer Sequenz zurück. Signatur: head(item()*) as item()?.
head array:head gibt das erste Item des Arrays zurück. Signatur: head(array(*)) as item()*.
hours-from-dateTime gibt die Stunde von xs:dateTime zurück. Signatur: hours-from-dateTime(xs:dateTime?) as xs:integer?.
hours-from-duration gibt die Anzahl der Stunden in einer xs:duration zurück. Signatur: hours-from-duration(xs:duration?) as xs:integer?.
hours-from-time gibt die Stunde von xs:time zurück. Signatur: hours-from-time(xs:time?) as xs:integer?.
implicit-timezone gibt die implizite Zeitzone aus dem Kontext zurück. Signatur: implicit-timezone() as xs:dayTimeDuration.
in-scope-prefixes gibt eine Liste aller Namespace-Präfixe aus, die im Kontext verwendet werden. Signatur: in-scope-prefixes(element()) as xs:string*.
index-of 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*.
insert-before Die "insert-before"-Funktion fügt ab einer bestimmten Position zusätzliche Items in eine ursprüngliche Sequenz ein, sodass im Ergebnis eine neue Sequenz entsteht. Signatur: insert-before(item()*, xs:integer, item()*) as item()*.
insert-before array:insert-before erlaubt, an einer bestimmten Position einen zusätzlichen Wert einzufügen. Signatur: insert-before(array(*), xs:integer, item()*) as array(*).
join 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()?.
json-to-xml konvertiert JSON-Daten in ein XML-Dokument. Signatur: json-to-xml(xs:string) as document-node(). Alternative Signatur: json-to-xml(xs:string, map(*)) as document-node().
keys map:keys gibt eine Sequenz aller Schlüsselwerte zurück. Signatur: keys(map(*)) as xs:anyAtomicType*.
last gibt die Position des letzten Kontextnodes zurück. Signatur: last() as xs:integer.
local-name 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.
log gibt den natürlichen Logarithmus eines Wertes zurück. Signatur: log(xs:double?) as xs:double?.
log10 gibt den 10er-Logarithmus eines Wertes zurück. Signatur: log10(xs:double?) as xs:double?.
lower-case konvertiert jeden Großbuchstaben eines Strings in den entsprechenden Kleinbuchstaben. Signatur: lower-case(xs:string?) as xs:string.
matches 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.
max gibt den Maximalwert mehrerer Zahlenwerte zurück. Signatur: max(xs:anyAtomicType*) as xs:anyAtomicType?. Alternative Signatur: max(xs:anyAtomicType*, xs:string) as xs:anyAtomicType?.
merge 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(*).
min gibt den Minimalwert mehrerer Zahlenwerte zurück. Signatur: min(xs:anyAtomicType*) as xs:anyAtomicType?. Alternative Signatur: min(xs:anyAtomicType*, xs:string) as xs:anyAtomicType?.
minutes-from-dateTime gibt die Minute von xs:dateTime zurück. Signatur: minutes-from-dateTime(xs:dateTime?) as xs:integer?.
minutes-from-duration gibt die Anzahl der Minuten in einer xs:duration zurück. Signatur: minutes-from-duration(xs:duration?) as xs:integer?.
minutes-from-time gibt die Minute von xs:time zurück. Signatur: minutes-from-time(xs:time?) as xs:integer?.
month-from-date gibt den Monat von xs:date zurück. Signatur: month-from-date(xs:date?) as xs:integer?.
month-from-dateTime gibt den Monat von xs:dateTime zurück. Signatur: month-from-dateTime(xs:dateTime?) as xs:integer?.
months-from-duration 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?.
normalize-space 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.
number 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.
one-or-more Die Funktion "one-or-more" überprüft, ob eine Sequenz überhaupt Inhalte hat: Mindestens ein Item muss vorhanden sein. Signatur: one-or-more(item()*) as item()+.
parse-json 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()?.
path gibt den XPath-Pfad eines Nodes zurück. Signatur: path() as xs:string?. Alternative Signatur: path(node()?) as xs:string?.
pi liefert eine Annährung an die Zahl Pi: 3,14 ... Signatur: pi() as xs:double.
position Nummer des aktuellen Items in der Sequenz. Signatur: position() as xs:integer.
put 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(*).
put 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()).
regex-group 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.
remove Die "remove"-Funktion löscht bestimmte Items (die sich aus ihrer Indexposition ergeben) aus einer Sequenz. Signatur: remove(item()*, xs:integer) as item()*.
remove 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(*).
remove 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(*).
replace 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.
reverse kehrt die Reihenfolge der Items in einer Sequenz um. Signatur: reverse(item()*) as item()*.
reverse array:reverse gibt ein Array zurück, dessen Items in umgekehrter Reihenfolge angeordnet sind. Signatur: reverse(array(*)) as array(*).
round 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?.
round-half-to-even 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?.
seconds-from-dateTime gibt die Sekunden von xs:dateTime zurück. Signatur: seconds-from-dateTime(xs:dateTime?) as xs:decimal?.
seconds-from-duration gibt die Anzahl der Sekunden in einer xs:duration zurück. Signatur: seconds-from-duration(xs:duration?) as xs:decimal?.
seconds-from-time 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.
sin gibt den Sinus eines Wertes zurück. Signatur: sin(xs:double?) as xs:double?.
size array:size ermittelt die Größe des Arrays Signatur: size(array(*)) as xs:integer.
size map:size gibt die Anzahl der Map-Entries zurück. Signatur: size(map(*)) as xs:integer.
snapshot generiert eine tiefe Kopie einer Sequenz, mit allen Elementen und Attributen. Signatur: snapshot() as item(). Alternative Signatur: snapshot(item()*) as item()*.
sort sortiert eine Sequenz, basiert ggf. auf einer Funktion als Sortierschlü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()*.
sort 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(*).
sqrt gibt die Quadratwurzel eines Wertes zurück. math:sqrt(2) ergibt den Wert 1.4142135623731. Signatur: sqrt(xs:double?) as xs:double?.
starts-with 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.
string konvertiert z.B. einen Textnode in eine Zeichenkette. Signatur: string() as xs:string. Alternative Signatur: string(item()?) as xs:string.
string-join 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.
string-length 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*.
subarray 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(*).
subsequence 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ässt 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()*.
substring 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.
substring-after 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.
substring-before 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.
sum summiert eine Liste von Zahlen. Signatur: sum(xs:anyAtomicType*) as xs:anyAtomicType. Alternative Signatur: sum(xs:anyAtomicType*, xs:anyAtomicType?) as xs:anyAtomicType?.
system-property gibt den Wert eines Systempropertys zurück. Vgl. available-system-properties. Signatur: system-property(xs:string) as xs:string.
tail gibt alle Items einer Sequenz zurück, ausgenommen das erste. Vgl. fn:head. Signatur: tail(item()*) as item()*.
tail array:tail gibt ab dem zweiten Item alle Folge-Items zurück. Signatur: tail(array(*)) as array(*).
tan gibt den Tangens eines Wertes zurück. Signatur: tan(xs:double?) as xs:double?.
timezone-from-date gibt die Zeitzone von xs:date zurück. Signatur: timezone-from-date(xs:date?) as xs:dayTimeDuration?.
timezone-from-dateTime gibt die Zeitzone von xs:dateTime zurück. Signatur: timezone-from-dateTime(xs:dateTime?) as xs:dayTimeDuration?.
timezone-from-time gibt die Zeitzone von xs:time zurück. Signatur: timezone-from-time(xs:time?) as xs:dayTimeDuration?.
tokenize 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*.
transform startet eine XSL-Transformation mit einem dynamisch geladenen XSL-Stylesheet. Signatur: transform(map(*)) as map(*).
translate 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.
unparsed-text 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.
unparsed-text-lines 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*.
upper-case konvertiert jeden Kleinbuchstaben eines Strings in den entsprechenden Großbuchstaben. Signatur: upper-case(xs:string?) as xs:string.
xml-to-json 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?.
year-from-date gibt das Jahr aus xs:date zurück. Signatur: year-from-date(xs:date?) as xs:integer?.
year-from-dateTime gibt das Jahr aus xs:dateTime zurück. Signatur: year-from-dateTime(xs:dateTime?) as xs:integer?.
years-from-duration gibt die Anzahl der Jahre aus einer xs:duration zurück. Signatur: years-from-duration(xs:duration?) as xs:integer?.
zero-or-one stellt sicher, dass eine Sequenz maximal ein Item haben darf; die Sequenz kann auch leer sein. Signatur: zero-or-one(item()*) as item()?.

wg / 28. August 2021



Fragen? Anmerkungen? Tipps?

Bitte nehmen Sie Kontakt zu mir auf.




Zahlenfunktionen

abs

math:acos

math:asin

math:atan

avg()

math:cos

math:exp

math:exp10

format-integer

format-number

math:log

math:log10

max()

min()

number()

math:pi

math:pow

math:sin

math:sqrt

sum()

math:tan

to

Statistikwerte als Map berechnen

Minimale, maximale und durchschnittliche Spannweiten

Zahlen-Rundungsfunktionen

ceiling

floor

round

round-half-to-even

Zeit ist Geld

Toll, ein Kalender

Stringfunktionen

XPath: analyze-string

XSL 2.0: xsl:analyze-string

xsl:matching-substring

XSL 2.0: xsl:matching-substring

xsl:non-matching-substring

XSL 2.0: xsl:non-matching-substring

XPath: Codepoints

XPath: compare

XPath: concat

XPath: contains

XPath ends-with

XPath: lower-case

XPath: matches

XPath: normalize-space

Reguläre Ausdrücke

Reguläre Ausdrücke in C#.NET

XPath: replace

XPath: starts-with

XPath: string oder xs:string?

XPath: string-join

XPath: substring, string-length

XPath: substring-after

XPath: substring-before

XPath: tokenize

XPath: translate

XPath: upper-case

XPath: Sequenz-Funktionen

XPath: collection

XPath: copy-of

XPath: count()

XPath: data

XPath: distinct-values

Gruppieren in XPath 1.0/XSL 1.0

XPath: exactly-one

XPath Sequenzen: concat, union, except, intersect

XPath: deep-equal

XPath: Der Vergleich von leeren Sequenzen mit leeren Strings

XPath: empty

XPath: exists

XPath: filter

XPath: for-each

XPath: for-each-pair

XPath: fold-left

XPath: fold-right

XPath: function

XPath: generate-id()

head, tail, snapshot

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

XPath: innermost, outermost

XPath: in-scope-prefixes

XPath: insert-before

JSON

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

XPath: fn:json-doc

XPath: fn:parse-json

XPath 3.1: Map, xsl:map

XPath: map:size

XPath: map:keys

XPath: map:contains

XPath: map:find

XPath: map:put

XPath: map:remove

XPath: map:get

XPath: map:entry

XPath: map:merge

XPath: map:for-each

random-number-generator

Weitere Beispiele

xsl:map

xsl:map-entry

XPath: one-or-more

XPath: parse-xml, parse-xml-fragment

XPath: path

XPath: remove

XPath: reverse

XPath: serialize

XPath: subsequence

XPath: transform

XPath: unparsed-text

XPath: unparsed-text-lines

XPath: zero-or-one



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: info10@wilfried-grupe.de

www.wilfried-grupe.de/XPath_30_Funktionen.html