Gern stehe ich zur fachlichen Unterstützung in XML-Technologien, C#.NET, VisualBasic.NET und Java zur Verfügung. Sprechen Sie mich einfach an: Mail oder ☎ 0151 . 750 360 61


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.

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:

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?.
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?.
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?.
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).
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?.
gibt eine Liste der Umgebungsvariablen zurück. Signatur: available-environment-variables() as xs:string*.
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ößeren Zahl: ceiling(4.1) > 5 Signatur: ceiling(xs:numeric?) as xs:numeric?.
vergleicht zwei Strings auf der Codepoint-Ebene. Signatur: codepoint-equal(xs:string?, xs:string?) as xs:boolean?.
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()*.
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?.
verkettet mehrere Informationen zu einem String. Signatur: concat(xs:anyAtomicType?, xs:anyAtomicType?, xs:anyAtomicType?) as xs:string.
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.
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.
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 eine 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.
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 . 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()*.
ü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(*).
gibt den Wert einer Umgebungsvariablen zurück. Signatur: environment-variable(xs:string) as xs:string?.
erzwingt, dass eine Sequenz 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.
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 Umfangs 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 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.
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?.
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.
gibt eine Liste aller Namespace-Präfixe aus, 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, sodass im Ergebnis eine neue Sequenz entsteht. Signatur: insert-before(item()*, xs:integer, item()*) as item()*.
array:insert-before erlaubt, an einer bestimmten Position einen 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(*).
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 ein 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 Sequenz überhaupt Inhalte hat: Mindestens ein Item muss 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(*).
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 Sequenz. 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.
kehrt die Reihenfolge der Items in einer Sequenz 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?.
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 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()*.
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.
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ä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()*.
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 Systempropertys 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.
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*.
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?.
stellt sicher, dass eine Sequenz maximal ein Item haben darf; die Sequenz kann auch leer sein. Signatur: zero-or-one(item()*) as item()?.

wg / 24. November 2018



Fragen? Anmerkungen? Tipps?

Bitte nehmen Sie Kontakt zu mir auf.




Zahlenfunktionen

avg()

min()

max()

sum()

Zahlen-Rundungsfunktionen

Zeit ist Geld

Toll, ein Kalender

Zeitkalkulation in Java

Stringfunktionen

XPath: analyze-string

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 Java

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

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

Anonyme Funktionen

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: one-or-more

XPath: fn:parse-json

XPath 3.0: path

XPath: remove

XPath: reverse

XPath: serialize

XPath: subsequence

XPath: unparsed-text

XPath: unparsed-text-lines

XPath: zero-or-one

XPath 3.1: Map, xsl:map

XPath: transform

XPath 3.1: Array

available-environment-variables

system-properties

XML auswerten mit Powershell



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