Textfunktionen

Die Liste zeigt die Textfunktionen, die Sie in Ausdrücken verwenden können.


Funktion	Beschreibung
`~=`	Kann Teil einer `If`- oder `Case`-Anweisung sein. Gibt `true` zurück, wenn die Zeichenfolge für den regulären Ausdruck `Arg2` mit der Zeichenfolge `Arg1` übereinstimmt. Beispiele: `If( "aab" ~= "a+" , "true", "false" )` `Case when "aba" ~= ".a+$" then "true" else "false" end`
`Concatenate(Arg1, ...)`	Konkateniert (verkettet) alle Argumente zu einer Zeichenfolge. Bei einem Argument ist das Ergebnis die Verkettung aller Zeilen. Bei mehreren Argumenten wird jede Zeile einzeln konkateniert. Die Argumente können von jedem beliebigen Typ sein, werden jedoch in Zeichenfolgen konvertiert. Das Ergebnis ist eine Zeichenfolge. Null-Argumente werden ignoriert. Beispiele: `Concatenate("April ", 20+1, "st")` → `"April 21st"` `Concatenate(null, "Ape")`→ `"Ape"` `Concatenate (null, null)` → (Empty)
`Find(Arg1, Arg2, Arg3)`	Gibt den Index der ersten Fundstelle der Zeichenfolge `Arg1` in `Arg2` zurück. `Arg3` gibt optional an, welche Übereinstimmung zurückgegeben werden soll. Wenn kein drittes Argument angegeben ist, wird die erste Übereinstimmung zurückgegeben. Wenn keine Übereinstimmung gefunden wird, wird 0 zurückgegeben. Bei der Suche wird die Groß-/Kleinschreibung berücksichtigt. Die ersten beiden Argumente sind vom Typ String und das dritte Argument sowie das Ergebnis sind vom Typ Integer. Wenn `Arg1` die leere Zeichenfolge ist, wird 0 zurückgegeben. Beispiele: `Find("lo", "Hello")` → 4 `Find("a", "Hello")` → 0 `Find("", "Hello")` → 0 `Find("", null)` → (Empty) `If(Find("Pri 1", [Col1])>0, "Important", "Not important")` `Find("a", "ababab")` → 1 `Find("a", "ababab", 2)` → 3 `Find("a", "ababab", 10)` → 0
`Left(Arg1, Arg2)`	Gibt die ersten `Arg2` Zeichen der Zeichenfolge `Arg1` zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge). `Arg2` ist vom Typ Real (reelle Zahl), aber nur mit der Ganzzahl verwendet. Wenn `Arg2` `>` die Länge von `Arg1` ist, wird die ganze Zeichenfolge zurückgegeben. Wenn `Arg2` negativ ist, wird die Anzahl der Zeichen `Arg2` von der rechten Seite der Zeichenfolge `Arg1` entfernt. Beispiele: `Left("Daddy", 1)` → `"D"` `Left("Daddy", 3.99)` → `"Dad"` `Left("Daddy", 386)` → `"Daddy"` `Left("Daddy", -1)` → `"Dadd"`
`Len(Arg1)`	Gibt die Länge von `Arg1` zurück. `Arg1` hat den Typ String (Zeichenfolge) und das Ergebnis hat den Typ Integer (Ganzzahl). Beispiele: `Len("Hello")` → 5 `Len(null)` → (Empty)
`Lower(Arg1)`	Gibt `Arg1` in Kleinbuchstaben zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge).
`Mid(Arg1, Arg2, Arg3)`	Gibt die Teilzeichenfolge von `Arg1` beginnend mit dem Index `Arg2` mit einer Länge von `Arg3` Zeichen zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge). `Arg2` und `Arg3` sind vom Typ Real (reelle Zahl), es wird jedoch nur der Teil mit der Ganzzahl verwendet. Wenn `Arg2 > Len(Arg1)` ist, wird eine leere Zeichenfolge zurückgegeben. Ansonsten gilt: Wenn `Arg2+Arg3 > Len(Arg1)` ist, wird `Arg3` an `1+Len(Arg1)-Arg2` angepasst. Wenn weder `Arg2` noch `Arg3` negativ ist oder wenn `Arg2` Null ist, wird ein Fehler zurückgegeben. Beispiele: `Mid("Daddy", 2, 3)` → `"add"` `Mid("Daddy", 386, 4)` → `""` `Mid("Daddy", 4, 386)` → `"dy"` `Mid("Daddy", -1, 2)` → (Empty) `Mid("Daddy", 2, -1)` → (Empty)
`MostCommon(Arg1)`	Gibt den häufigsten Wert der angegebenen Spalte zurück. Wenn mehrere Werte gleich häufig sind, wird der erste verwendet. Beispiel: `MostCommon([Column])`
`NameDecode(Arg1)`	Ersetzen aller Codes in Teilzeichenfolgen durch decodierte Zeichen. Spaltennamen in Spotfire werden als UTF-16-codierte Zeichenfolgen gespeichert. Beispiel: `NameDecode("Column %02D")`
`NameEncode(Arg1)`	Codiert Zeichen in der Zeichenfolge so, dass die Zeichenfolge nur Zeichen enthält, die dem regulären Ausdruck `[.0-9a-zA-Z]` entsprechen. Spaltennamen in Spotfire werden als UTF-16-codierte Zeichenfolgen gespeichert. Beispiel: `NameEncode("Column £")`
`Repeat`	Wiederholt eine Zeichenfolge so oft wie angegeben. Beispiel: `Repeat("Hello", 2)` → `"HelloHello"`
`Right(Arg1, Arg2)`	Gibt die letzten `Arg2` Zeichen der Zeichenfolge `Arg1` zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge). `Arg2` ist vom Typ Real (reelle Zahl), aber nur mit der Ganzzahl verwendet. Wenn `Arg2 >` die Länge von `Arg1` ist, wird die ganze Zeichenfolge zurückgegeben. Wenn `Arg2` negativ ist, wird die Anzahl der Zeichen `Arg2` von der linken Seite der Zeichenfolge `Arg1` entfernt. Beispiele: `Right("Daddy", 1)` → `"y"` `Right("Daddy", 3.99)` → `"ddy"` `Right("Daddy", 386)` → `"Daddy"` `Right("Daddy", -1)` → `"addy"`
`RXExtract(Arg1, Arg2, Arg3)`	Gibt den Teil einer Zeichenfolge (`Arg1`) zurück, der einem regulären Ausdruck (`Arg2`) entspricht. `Arg3` bestimmt, welche Übereinstimmung verwendet wird, wenn mehrere Übereinstimmungen vorhanden sind. Beispiele: `RXExtract([Column], "l+", 1)` `RXExtract("Parallel", "l+", 1)` → `"ll"` `RXExtract("Parallel", "l+", 2)` → `"l"`
`RXReplace(Arg1, Arg2, Arg3, Arg4)`	Ersetzt eine Teilzeichenfolge gemäß einem regulären Ausdruck. Suchen Sie nach dem regulären Ausdruck `Arg2` in `Arg1` und ersetzen Sie ihn durch `Arg3`. `Arg4` gibt die Optionen für die Ersetzung an: "g" gibt an, dass, wenn `Arg2` mehr als einmal übereinstimmt, alle Übereinstimmungen ersetzt werden sollen. "i" gibt an, dass beim Vergleich zwischen Groß- und Kleinschreibung unterschieden werden soll. "s" für den einzeiligen Modus gibt an, dass der Punkt (.) mit jedem Zeichen übereinstimmt (anstatt mit jedem Zeichen außer dem Zeilenvorschubzeichen). Einige Zeichen wie der umgekehrte Schrägstrich "\" und die Klammern "(" und ")" müssen für das Arbeiten mit berechneten Spalten maskiert werden. Da Klammern zur Gruppierung in regulären Ausdrücken verwendet werden, müssen "(" und ")" durch einen umgekehrten Schrägstich geschützt werden, wenn das ( or )-Zeichen abgeglichen werden soll. Wenn dieses Zeichen jedoch in einem regulären Ausdruck verwendet wird, sind doppelte Schrägstiche erforderlich, um die Spotfire-Zeichenfolge und den regulären Ausdruck zu schützen. Weitere Informationen finden Sie in der Literatur zu regulären Ausdruckssprachelementen, beispielsweise bei MSDN. Beispiele: `RXReplace("Hello", "L+", "LL", "i")` → `"HeLLo"` `RXReplace("3 Minor", "(\\d).*", "$1", "")` → 3 `RXReplace([Column with values within parenteses], "\$89\$", "", "")` `RXReplace("change\\slashdirection","\\\\","/","")` → `change/slashdirection` (Im letzten Beispiel muss der umgekehrte Schrägstrich zweimal maskiert werden, einmal für die Spotfire-Zeichenfolge und einmal für den regulären Ausdruck.)
`Split(Arg1, Arg2, Arg3)`	Teilt die Werte in `Arg1` in mehrere Teilzeichenfolgen auf, wobei `Arg2` als Trennzeichen verwendet wird. `Arg3` gibt an, welcher der Werte als neue Spalte zurückgegeben werden soll. Es wird nur eine Spalte zurückgegeben. Verwenden Sie ein negatives `Arg3`, um anzugeben, dass die Teilung vom Ende der Zeichenfolge bis zum Anfang und nicht vom Anfang zum Ende durchgeführt werden soll. Wenn beispielsweise eine Spalte namens "X" mit dem Wert "`a.b`" mit dem Separator "`.`" in zwei Teile geteilt ist, gibt `Split([X],".",1)` "`a`" zurück und `Split([X],".",2)` gibt "`b`" zurück. Beispiele: `Split([Column]," ",2)` `Split([Column]," ",-2)` `Split([Column]," / ",3)`
`Substitute(Arg1, Arg2, Arg3)`	Ersetzt alle Vorkommen von `Arg2` in `Arg1` durch`Arg3`. Bei der Suche wird die Groß-/Kleinschreibung berücksichtigt. Beispiel: `Substitute("Test","t","ting")` → `"Testing"`
`Substring(Arg1, Arg2, Arg3)`	Gibt die Teilzeichenfolge von `Arg1` beginnend mit dem Index `Arg2` mit einer Länge von `Arg3` Zeichen zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge). `Arg2` und `Arg3` sind vom Typ Real (reelle Zahl), es wird jedoch nur der Teil mit der Ganzzahl verwendet. Wenn `Arg2 > Len(Arg1)` ist, wird eine leere Zeichenfolge zurückgegeben. Ansonsten gilt: Wenn `Arg2 + Arg3 > Len(Arg1)` ist, wird `Arg3` an `1+Len(Arg1) - Arg2` angepasst. Wenn weder `Arg2` noch `Arg3` negativ ist oder wenn `Arg2` Null ist, wird ein Fehler zurückgegeben. Beispiele: `Substring("Daddy", 2, 3)` → `"add"` `Substring("Daddy", 386, 4)` → `""` `Substring("Daddy", 4, 386)` → `"dy"` `Substring("Daddy", -1, 2)` → (Empty) `Substring("Daddy", 2, -1)` → (Empty)
`Trim(Arg1)`	Entfernt Leerzeichen vor und nach einer Zeichenfolge. Beispiel: `Trim(" Example "`) → `"Example"`
`UniqueConcatenate(Arg1)`	Konkateniert die in Zeichenfolgen konvertierten eindeutigen Werte. Die Werte werden gemäß dem Comparator sortiert. Beispiel: `UniqueConcatenate([Column])`
`Upper(Arg1)`	Gibt `Arg1` in Großbuchstaben zurück. `Arg1` und das Ergebnis sind vom Typ String (Zeichenfolge). Beispiel: `Upper("hello")` → `"HELLO"`

Siehe auch Funktionen.