Home
Über mich
Blog
Veröffentlichungen
IT-Trainings
Impressum


XPath Funktionen

Zusammenfassung:

XPath 3.0 und XPath 3.1 bieten mehr als 300 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 über 200 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:

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 Die Funktion "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?.
adjust-dateTime-to-timezone Die Funktion "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?.
adjust-time-to-timezone Die Funktion "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?.
analyze-string generiert ein "analyze-string-result"-Element mit den Childnodes "match" bzw. "non-match". Siehe xsl:analyze-string. 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 array:append fügt einem bestehenden Array ein weiteres Feld hinzu. Signatur: append(array(*), item()*) as array(*).
apply fn:apply startet einen dynamischen Funktionsaufruf mit einem Array als Argumentliste. Beispiel: fn:apply(fn:concat#3, ['X', 'M', 'L']) ergibt XML. Signatur: apply(function(*), array(*)) as item()*.
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 available-environment-variables() gibt eine Liste aller Environment-Namen zurück, die in einer Sequence abgearbeitet werden kann. Zu empfehlen in Verbindung mit fn:environment-variable. Signatur: available-environment-variables() as xs:string*.
available-system-properties Gibt eine Liste der verfügbaren System-properties zurück. Vgl. fn:system-property. Signatur: available-system-properties() as xs:QName*.
avg berechnet den Durchschnitt mehrerer Zahlenwerte. Signatur: avg(xs:anyAtomicType*) as xs:anyAtomicType?.
base-uri fn:base-uri() gibt die Adresse eines Nodes zurück, beispielsweise den Pfad der XML-Input-Datei. Vgl. fn:static-base-uri(). Signatur: base-uri() as xs:anyURI?. Alternative Signatur: base-uri(node()?) as xs:anyURI?.
boolean Errechnet den effektiven Boolean-Wert einer Sequenz. Signatur: boolean(item()*) as xs:boolean.
ceiling rundet einen Zahlenwert auf zur nächstgrößren Zahl: ceiling(4.1) > 5 Signatur: ceiling(xs:numeric?) as xs:numeric?.
codepoint-equal codepoint-equal vergleicht zwei Strings auf der Codepoint-Ebene. Signatur: codepoint-equal(xs:string?, xs:string?) as xs:boolean?.
codepoints-to-string 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 "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 Die "concat"-Funktion verkettet mehrere Informationen zu einem String. Signatur: concat(xs:anyAtomicType?, xs:anyAtomicType?, xs:anyAtomicType?) as xs:string.
contains 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.
contains map:contains prüft, ob eine map einen bestimmten Schlüssel aufweist. Beispiel: <xsl:value-of select="map:contains(map{'Theo':27}, 'Theo')"/> ergibt den Wert true(). Signatur: contains(map(*), xs:anyAtomicType) as xs:boolean.
contains-token Prüft, ob die gegebenen Zeichenkette einem Token entspricht, ggf. unter den Regeln der Callation. fn:contains-token('eins zwei drei ', 'eins') ergibt true. fn:contains-token('Weg Straße Pfad ', 'Strasse', 'http://www.w3.org/2013/collation/UCA?lang=de;strength=primary') ergibt ebenfalls true. 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 Generiert eine tiefe Kopie einer Sequenz bzw. eines Items. 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-time gibt die aktuelle Zeit zurück. Signatur: current-time() as xs:time.
data 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*.
dateTime Berechnet aus xs:date und xs:time die xs:dateTime. 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-collation Gibt den Namespace der Defaultcollation zurück: http://www.w3.org/2005/xpath-functions/collation/codepoint. Zum Thema Collations siehe compare. Signatur: default-collation() as xs:string.
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*.
doc Liest ein XML-Dokument einer URI ein. Signatur: doc(xs:string?) as document-node()?.
doc-available doc-available gibt den Wert true zurück, wenn die Funktion fn:doc($uri) einen Dokumentnode zurückgeben würde. Signatur: doc-available(xs:string?) as xs:boolean.
document liest ein externes XML-Dokument ein. Signatur: document(item()*) as node()*. Alternative Signatur: document(item()*, node()) as node()*.
empty "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. map:entry('A', 'Achtungfertiglos') erzeugt also map{'A':'Achtungfertiglos'}. Signatur: entry(xs:anyAtomicType, item()*) as map(*).
environment-variable Gibt den Wert einer Umgebungsvariablen zurück. Siehe fn:available-environment-variables. <root><xsl:for-each select="available-environment-variables()"><wert envname="{.}"><xsl:value-of select="fn:environment-variable(.)"/></wert></xsl:for-each></root> Signatur: environment-variable(xs:string) as xs:string?.
exactly-one Die "exactly-one"-Funktion erzwingt, daß eine Sequence 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.
exp exp10 berechnet den Wert mit der Potenzzahl zur Zahl e (2.71828182845905). exp(3) ergibt den Wert 20.0855369231877. Signatur: exp(xs:double?) as xs:double?.
exp10 exp10 berechnet den Wert mit der Potenzzahl zur Basis 10. exp10(3) ergibt den Wert 1000. Signatur: exp10(xs:double?) as xs:double?.
false Gibt den xs:boolean Wert false() zurück. Signatur: false() as xs:boolean.
filter Gibt jene Items einer Sequenz zurück, die in der anonymen Funktion ein true() ergeben. Vgl. fn:for-each. Signatur: filter(item()*, function(item()) as xs:boolean) as item()*.
filter array:filter generiert ein Array mit allen Einträgen, für die die zu implementierende 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 Items von links nach rechts; das Ergebnis wird in einer (anonymen?) Funktion berechnet. Signatur: fold-left(item()*, item()*, function(item()*, item()) as item()*) as item()*.
fold-right verarbeitet Items von rechts nach links; das Ergebnis wird in einer (anonymen?) Funktion berechnet. Signatur: fold-right(item()*, item()*, function(item(), item()*) as item()*) as item()*.
for-each 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 ermöglicht den Einsatz anonymer Funktionen, um die einzelnen Felder eines Arrays zu modifizieren. Signatur: for-each(array(*), function(item()*) as item()*) as array(*).
for-each map:for-each benötigt eine zusätzliche Funktion, die die Ergebnisse verkettet. Mit den enormen Möglichkeiten anonymer Funktionsaufrufe steht die flexible Implementierung diverser Logiken frei. Signatur: for-each(map(*), function(xs:anyAtomicType, item()*) as item()*) as item()*.
for-each-pair Die XPath-Funktion "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 implementiert. Signatur: for-each-pair(array(*), array(*), function(item()*, item()*) as item()*) as array(*).
format-date formatiert einen date-Wert nach einer Formatierungsvorschrift. 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 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.
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?.
function-available function-available prüft, ob eine Funktion zur Verfügung steht. Signatur: function-available(xs:string) as xs:boolean. Alternative Signatur: function-available(xs:string, xs:integer) as xs:boolean.
function-name Gibt den Namen einer Funktion zurück. Beispiel: fn:function-name(math:sin#1) ergibt math:sin. Signatur: function-name(function(*)) as xs:QName?.
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 eines Arrays, 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 Die XPath-Funktion array:head gibt das erste Feld 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 den Wert der impliziten Zeitzone zurück. Beispiel: fn:implicit-timezone() ergibt PT2H. Tip: mit unterschiedlichen XSL-Prozessoren erhalten wir unterschiedliche Ergebnisse. Signatur: implicit-timezone() as xs:dayTimeDuration.
in-scope-prefixes in-scope-prefixes gibt eine Liste aller Namespace-prefixe, 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, so daß im Ergebnis eine neue Sequenz entsteht. Signatur: insert-before(item()*, xs:integer, item()*) as item()*.
insert-before array:insert-before kann an einer bestimmten Position einen zusätzlichen Wert einfü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 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 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 geben eine Sequenz aller Schlüsselwerte in einer Map zurück. Signatur: keys(map(*)) as xs:anyAtomicType*.
last Gibt die Position des letzten Kontextnodes zurück. Häufige Verwendung bei <xsl:if test="position() != last()"/>. 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 zurück. Signatur: name() as xs:string. Alternative Signatur: name(node()?) as xs:string.
namespace-uri Gibt den Namespace-URI-Teil eines Nodes zurück. Signatur: namespace-uri() as xs:anyURI. Alternative Signatur: namespace-uri(node()?) as xs:anyURI.
nilled Gibt true() zurück für ein nilled-element. Signatur: nilled() as xs:boolean?. Alternative Signatur: nilled(node()?) as xs:boolean?.
node-name Gibt den Node-Name 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.
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 Sequence überhaupt Inhalte hat: mindestens ein Item muß vorhanden sein. Signatur: one-or-more(item()*) as item()+.
parse-json fn:parse-json parst einen JSON-String und gibt den Wert als Map oder Array zurück. Signatur: parse-json(xs:string?) as item()?. Alternative Signatur: parse-json(xs:string?, map(*)) as item()?.
parse-xml parse-xml übernimmt einen Stringparameter als XML Dokument und gibt den Rootnode zurück. Signatur: parse-xml(xs:string?) as document-node(element(*))?.
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.
pow math:pow(a, b) berechnet den Potenzwert von Exponent b zur Basis a. math:pow(3,2) ergibt den Wer 9. Signatur: pow(xs:double?, xs:numeric) as xs:double?.
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(*).
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 fn:remove-Funktion löscht bestimmte Items (die sich aus ihrer Indexposition ergeben) aus einer Sequence. Signatur: remove(item()*, xs:integer) as item()*.
remove array:remove entfernt aus einem Array jenes Feld, 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 Die "reverse"-funktion kehrt die Reihenfolge der Items in einer Sequence um. Signatur: reverse(item()*) as item()*.
reverse array:reverse gibt ein Array zurück, dessen Felder in umgekehrter Reihenfolge angeordnet sind. Signatur: reverse(array(*)) as array(*).
root fn:root() gibt den Root des Baumes, zu dem ein bestimmter Node gehört. Das ist wahrscheinlich, aber nicht zwingend, der Dokumentnode. <xsl:value-of select="fn:root()/child::*/fn:local-name()"/> gibt den Namen jenes Elements zurück, das also an oberster Stelle steht. Signatur: root() as node(). Alternative Signatur: root(node()?) as node()?.
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 Die Funktion "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 Die XPath-Funktion array:size ermittelt die Größe des Arrays. Signatur: size(array(*)) as xs:integer.
size map:size gibt die Anzahl der Entries in einer Map 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 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()*.
sort array:sort generiert ein Array, das alle Items des ursprünglichen Arrays beinhaltet, jedoch in sortierter Reihenfolge. Dabei ist es möglich, optional eine Collation sowie - ebenfalls optional - eine Function einzubinden. 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.
static-base-uri static-base-uri() gibt die Adresse bzw. Dateinamen des statischen Kontexts zurück, z.B. Name des XSLT-Dokuments. In XSLT 3.0 bzw. XQuery 3.0 können unterschiedliche Base-URIs angesprochen werden: die statische Analysephase zur Compile-Zeit ("kompiliertes" XSLT bzw. XQuery) und die dynamische Evaluation-Phase zur Laufzeit. Vgl. fn:base-uri(). Signatur: static-base-uri() as xs:anyURI?.
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 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. Als optionaler zweiter Parameter kann die Anzahl der Felder angegeben werden, die ab der Startposition einbezogen werden sollen. 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äß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()*.
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 System-Propertys zurück. Vgl. fn:available-system-properties. Zu empfehlen: <root><xsl:for-each select="fn:available-system-properties()"><wert property="{.}"><xsl:value-of select="fn:system-property(xs:string(.))"/></wert></xsl:for-each></root> 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 (also ohne das erste Item, das über array:head erreicht werden kann) alle Folge-Felder zurück. Signatur: tail(array(*)) as array(*).
tan Gibt den Tangens eines Wertes zurück. Signatur: tan(xs:double?) as xs:double?.
text gibt den Textinhalt eines Nodes zurück. Signatur: text() as item().
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 Die zero-or-one-Funktion stellt sicher, daß eine (optionale) Sequence maximal ein Item hat. Signatur: zero-or-one(item()*) as item()?.

qrpic/XPath_30_Funktionen.jpg

wg / 14. Oktober 2017




Fragen? Anmerkungen? Tips?

Bitte nehmen Sie Kontakt zu mir auf (info10@wilfried-grupe.de).



Vielen Dank für Ihr Interesse an meiner Arbeit.


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

Mobil: 0151. 750 360 61 * eMail: info10@wilfried-grupe.de