Zeichenfolgenfunktionen im Jitterbit Design Studio

Zeichenfolgenfunktionen sind das Mittel zur Manipulation von Zeichenfolgen in Skripten.

CountSubString

Deklaration

int CountSubString(string str, string subStr)

Syntax

CountSubString(<str>, <subStr>)

Erforderliche Parameter

• str: Eine zu durchsuchende Zeichenfolge
• subStr: Die Zeichenfolge, mit der gesucht wird

Beschreibung

Gibt die Anzahl der Vorkommen einer Teilzeichenfolge in einer Zeichenfolge zurück.

Beispiele

CountSubString("Mississippi", "iss"); // Gibt 2 zurück

DQuote

Deklaration

string DQuote(string str)

Syntax

DQuote(<str>)

Erforderliche Parameter

• str: Eine Zeichenfolge, die in doppelte Anführungszeichen gesetzt werden soll

Beschreibung

Setzt eine Zeichenfolge in doppelte Anführungszeichen und gibt das Ergebnis zurück. Eingebettete doppelte Anführungszeichen werden nicht escaped.

Beispiele

DQuote("any str"); // Returns ""any str""

DQuote('any "text" str');
// Returns ""any "text" str"" -- note that the embedded double quotes are not escaped

Format

Deklaration

string Format(string formatStr, type de)

Syntax

Format(<formatStr>, <de>)

Erforderliche Parameter

• formatStr: Die Formatzeichenfolge, die beim Formatieren der Zeichenfolge verwendet werden soll
• de: Ein Datenelement; falls erforderlich, wird es vor dem Formatieren in eine Zeichenfolge umgewandelt

Beschreibung

Gibt einen String im durch einen Format-String angegebenen Format zurück.

Die Format-Spezifikation ist die gleiche wie die, die in den Datum- und Zeitfunktionen verwendet wird; siehe den Abschnitt über Format-Strings. Sie ähnelt der Format-Spezifikation der Standard-C-Bibliothek printf.

Diese Funktion kann verwendet werden, um das Ausgabeformat für ein Ziel festzulegen. Sie ist nützlich, wenn das Standardausgabeformat von Jitterbit für einen Datentyp (wie Datum oder Double) nicht gewünscht ist. Der Aufruf der Format-Funktion muss der letzte Aufruf in einer Mapping-Formel sein, damit er den gemappten Wert hat.

Beispiele

Format("'%5d'", 2); // Gibt "'    2'" zurück

Index

Deklaration

int Index(string str, string subStr[, int n])

Syntax

Index(<str>, <subStr>[, <n>])

Erforderliche Parameter

• str: Ein zu durchsuchender String
• subStr: Der String, mit dem gesucht werden soll

Optionale Parameter

• n: Die spezifische Instanz von Interesse, falls mehr als eine Übereinstimmung vorhanden ist

Beschreibung

Gibt die Position eines Teil-Strings innerhalb eines Strings zurück.

In Fällen, in denen der Teil-String mehr als einmal im Hauptstring erscheint, wird das dritte Argument (n) verwendet, um zu bestimmen, welche spezifische Instanz des Teil-Strings von Interesse ist.

• Wenn n < 0 ist, beginnt die Instanzzählung vom Ende des Hauptstrings.
• Wenn |n| > der maximalen Anzahl von Vorkommen des Teil-Strings im Hauptstring, gibt die Funktion -1 zurück.

Andernfalls gibt die Funktion die Position des ersten Zeichens des Teil-Strings innerhalb des Hauptstrings zurück (beginnend bei Position 0).

Besondere Fälle zu beachten:

• n = 0 gibt dasselbe Ergebnis wie n = 1 zurück
• Wenn subStr eine leere Zeichenfolge ("") ist:
  • n >= 0 gibt immer 0 zurück
  • n \< 0 gibt immer Length(str) zurück

Beispiele

Index("Mississippi", "s"); // Returns 2
// When called with only two arguments
// the optional third argument defaults to 1,
// resulting in the index of the first match being returned

Index("Mississippi", "iss", 3); // Returns -1
// Searching for the 3rd instance of "iss" within Mississippi

Index("Mississippi", "si", 2); // Returns 6
// The 2nd instance of the sub-string
// "si" starts at position 6 as the
// first letter "M" starts at position 0

Index("Mississippi", "", 1); // Returns 0
Index("Mississippi", "", -1); // Returns 11

IsValidString

Deklaration

bool IsValidString(string str)

Syntax

IsValidString(<str>)

Erforderliche Parameter

• str: Eine zu validierende Zeichenfolge

Beschreibung

Gibt true zurück, wenn jedes Zeichen in einer Zeichenfolge gültig ist. Gültige Zeichen sind ASCII-Codes von 32 bis 126 einschließlich und beliebige Zeilenumbruch (LF), Wagenrücklauf (CR) oder Tabulator (TAB) Zeichen.

Beispiele

IsValidString("An Invalid String™");
// Returns 0 (false), as the trademark symbol in this font is a code greater than 128

IsValidString("A Valid Broken
String");
// Returns 1 (true)

Left

Deklaration

string Left(string str, int n)

Syntax

Left(<str>, <n>)

Erforderliche Parameter

• str: Eine Zeichenfolge
• n: Die Anzahl der Zeichen, die vom linken Ende zurückgegeben werden sollen

Beschreibung

Gibt n Zeichen einer Zeichenfolge zurück, beginnend von links (dem Anfang) einer Zeichenfolge.

Siehe auch die Funktionen Mid und Right.

Beispiele

Left("01234567890", 4);
// Gibt "0123" zurück

LPad

Deklaration

string LPad(string str, int n)

Syntax

LPad(<str>, <n>)

Erforderliche Parameter

• str: Ein String
• n: Die Anzahl der Zeichen vom linken Ende, die zurückgegeben werden sollen

Beschreibung

Fügt Leerzeichen links (am Anfang) eines Strings hinzu, bis der String n Zeichen enthält. Strings, die n oder mehr Zeichen enthalten, werden auf n Zeichen gekürzt.

LPad(str, -n) ist dasselbe wie RPad(str, n). Siehe die Funktion RPad.

Beispiele

LPad("01234567", 9);
// Returns " 01234567"
// Adds one space to the left side
// of the original string

LPad("1234567890", 9);
// Returns "123456789"

LPadChar

Deklaration

string LPadChar(string str, string padChar, int n)

Syntax

LPadChar(<str>, <padChar>, <n>)

Erforderliche Parameter

• str: Ein String
• padChar: Ein String, der zum Auffüllen von Zeichen verwendet wird; wenn mehr als ein Zeichen vorhanden ist, wird das erste Zeichen verwendet
• n: Die Anzahl der Zeichen vom linken Ende, die zurückgegeben werden sollen

Beschreibung

Fügt ein Auffüllzeichen links (am Anfang) eines Strings hinzu, bis der String n Zeichen enthält. Strings, die n oder mehr Zeichen enthalten, werden auf n Zeichen gekürzt.

LPadChar(str, " ", n) ist dasselbe wie LPad(str, n). Siehe die Funktion LPad.

Beispiele

LPadChar(1234567, "0", 10);
// Returns "0001234567"
LPadChar(1234567, ".0", 10);
// Returns "...1234567"

LTrim

Deklaration

string LTrim(string str)

Syntax

LTrim(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Entfernt Leerzeichen (Leerzeichen, Tabs) von links (am Anfang) eines Strings und gibt die verbleibenden Zeichen zurück.

Beispiele

LTrim(" Hello World!  ");
// Returns "Hello World!  "

LTrim("    Hello World!");
// Removes the leading tab character
// and returns "Hello World!"

LTrimChars

Deklaration

string LTrimChars(string str, string trimChars)

Syntax

LTrimChars(<str>, <trimChars>)

Erforderliche Parameter

• str: Ein zu bearbeitender String von links (dem Anfang)**
  
• trimChars:** Ein String von zu entfernenden Zeichen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle führenden Zeichen in einem String von links (dem Anfang), die mit den Zeichen im Trim-String übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion testet jedes führende Zeichen eines Strings, beginnend an der linken Kante, und prüft, ob es in den Trim-Zeichen gefunden wird. Wenn ja, wird es entfernt, und der Vorgang wird wiederholt, bis keine Übereinstimmung mehr vorhanden ist.

Dies kann verwendet werden, um andere Zeichen als die standardmäßigen Leerzeichen zu trimmen, wie zum Beispiel führende Doppelpunkte.

Siehe auch die Funktionen RTrimChars und TrimChars.

Beispiele

LTrimChars("::StartMsg :: Hello :: EndMsg::", ":");
// Returns "StartMsg :: Hello :: EndMsg::"

LTrimChars("// This is a comment", " /");
// Returns "This is a comment"

LTrimChars("// This is a comment", "/ ");
// Returns "This is a comment"

LTrimChars("// This is a comment", "/");
// Returns " This is a comment"

LTrimChars("// This is a comment", " ");
// Returns "// This is a comment"
// Returns the string unchanged as a space
// was not a leading character

Mid

Deklaration

string Mid(string str, int m, int n)

Syntax

Mid(<str>, <m>, <n>)

Erforderliche Parameter

• str: Ein String, aus dem ein Teilstring extrahiert werden soll

• m: Die nullbasierte Startzeichenposition, an der die Extraktion des Teilstrings beginnt

• n: Die Länge (Anzahl der Zeichen) des zu extrahierenden Teilstrings

Beschreibung

Gibt einen Teil eines Strings zurück, beginnend mit dem Zeichen an der Position m über eine Länge von n Zeichen.

Siehe auch die Funktionen Left und Right.

Beispiele

Mid("Jitterbit", 2, 3);
// Returns "tte"

Mid("01234567890", 7, 3);
// Returns "789"

// Passing the same string as an
// integer with a leading zero
// returns a different result
Mid(01234567890, 7, 3);
// Returns "890"

ParseURL

Deklaration

array ParseURL(string url)

Syntax

ParseURL(<url>)

Erforderliche Parameter

• url: Eine Zeichenkette, die eine URL zum Parsen enthält

Beschreibung

Parst eine URL-Zeichenkette und gibt ein Array von dekodierten Werten zurück. Die Werte sind so gekennzeichnet, dass sie entweder nach Index oder nach Feldnamen abgerufen werden können.

Beim Abrufen von Werten aus dem Ergebnis wird die Groß- und Kleinschreibung eines Feldnamens ignoriert. Siehe auch die Funktionen URLDecode und URLEncode.

Beispiele

url = "http://hostname/user?email=john1990%40example.com&name=John%20Smith";
arr = ParseURL(url);

email = arr[0];
// "email" will be john1990@example.com
email = arr["email"];
// same as previous

name = arr["name"];
// "name" will be "John Smith"
name = arr["Name"];
// Same as previous;
// case is ignored for field names

Quote

Deklaration

string Quote(string str)

Syntax

Quote(<str>)

Erforderliche Parameter

• str: Eine Zeichenkette, die in einfache Anführungszeichen gesetzt werden soll

Beschreibung

Setzt eine Zeichenkette in einfache Anführungszeichen und gibt das Ergebnis zurück. Eingebettete einfache Anführungszeichen werden nicht escaped.

Beispiele

Quote("Any string");
// Returns "'Any string'"

Quote("Ain't escaped");
// Returns "'Ain't escaped'" -- note that the embedded quote is not escaped

RegExMatch

Deklaration

int RegExMatch(string str, string exp[, type var1,... type varN])

Syntax

RegExMatch(<str>, <exp>[, <var1>,... <varN>])

Erforderliche Parameter

• str: Ein String, der abgeglichen werden soll

• exp: Ein regulärer Ausdruck, der aus Gruppen besteht

Optionale Parameter

• var1...varN: Eine oder mehrere Variablennamen, die den markierten Teil-Ausdrücken des Ausdrucks zugeordnet werden sollen

Beschreibung

Vergleicht einen regulären Ausdruck mit einem Eingabestring, speichert die markierten Teil-Ausdrücke in Variablen und gibt die Anzahl der Übereinstimmungen zurück.

Gibt die Gesamtzahl der markierten Teil-Ausdrücke zurück (die mehr oder weniger als die tatsächlich bereitgestellten Variablen sein können). Zusätzliche Übereinstimmungen, die die Anzahl der bereitgestellten Variablen überschreiten, werden verworfen. Wenn es keine Übereinstimmungen gibt, wird -1 zurückgegeben.

Der reguläre Ausdruck folgt der Boost-Regulärer-Ausdruck-Bibliothek-Syntax. Es ist eine Variation der Perl-Regulärer-Ausdruck-Syntax.

Unicode-Zeichen, einschließlich Symbole wie Emojis, müssen mit ihren literalen Zeichen und nicht mit Unicode-Escape-Sequenzen abgeglichen werden. Zum Beispiel erfasst der Bereich "[😀-🤯]" (U+1F600 bis U+1F92F) erfolgreich das 🤔 (U+1F914) Symbol dazwischen.

Siehe auch die Funktion RegExReplace.

Beispiele

expression = "\D*";
// Expression that matches what aren't digits.

$reg_1 = RegExMatch("123", expression);
// Returns -1 because the input string contains digits.

$reg_2 = RegExMatch("123A" ,expression);
// Returns -1 because the input string starts with digits.

$reg_3 = RegExMatch("ABC", "[a-zA-Z]*");
// Returns 0 because a match was found with without matching sub-expressions.

$reg_4 = RegExMatch("a", "[a-z]");
// Returns 0 because the single character matches what the expression expected.

$reg_5 = RegExMatch("ab", "[a-z]");
// Returns -1 because the expression does not cover the entire input string and is expecting a single character.
// Refer to the note above for additional information.

$reg_6 = RegExMatch("ab", "[a-z]+");
// Returns 0.

$reg_7 = RegExMatch("ab", "a*b", "reg_7_value");
// Returns 0.
// Does not set the global variable "$reg_7_value" because there are no sub-expressions.

$reg_8 = RegExMatch("ab", "(a*b)", "reg_8_value");
// Returns 1 because the sub-expression was matched.
// Sets the global variable "$reg_8_value" to "ab".

$reg_9 = RegExMatch("[abc]", "(\\[)(.*)(\\])", "reg_9_test", "reg_9_value");
result = $reg_9;
// Sets the global variable "$reg_9_test" to "[".
// Sets the global variable "$reg_9_value" to "abc".
// Returns 3 because the character "]" also matched the last sub-expression.
// However, as there are only two variable names, the last match is not saved to a variable.

RegExReplace

Deklaration

string RegExReplace(string str, string exp, string format)

Syntax

RegExReplace(<str>, <exp>, <format>)

Erforderliche Parameter

• str: Eine Zeichenfolge, die durchsucht werden soll und in der übereinstimmende Teilzeichenfolgen ersetzt werden

• exp: Der reguläre Ausdruck in der Boost-Regulärer-Ausdruck-Bibliothek-Syntax, der verwendet wird, um nach Teilzeichenfolgen der Zeichenfolge zu suchen

• format: Eine Formatzeichenfolge in der Boost-Extended Format String Syntax

Beschreibung

Ersetzt alle Teilzeichenfolgen in einer Zeichenfolge, die einem Ausdruck entsprechen, unter Verwendung eines angegebenen Formats, um jede Teilzeichenfolge zu ersetzen. Alle Abschnitte der Zeichenfolge, die nicht mit dem Ausdruck übereinstimmen, werden unverändert in die zurückgegebene Zeichenfolge übergeben.

Der reguläre Ausdruck folgt der Boost-Regulärer-Ausdruck-Bibliothek-Syntax. Es handelt sich um eine Variation der Perl-Regulärer-Ausdruck-Syntax.

Unicode-Zeichen, einschließlich Symbole wie Emojis, müssen mit ihren literalen Zeichen und nicht mit Unicode-Escape-Sequenzen übereinstimmen. Zum Beispiel erfasst der Bereich "[😀-🤯]" (U+1F600 bis U+1F92F) erfolgreich das 🤔 (U+1F914) Symbol dazwischen.

Die Formatzeichenfolge folgt der Boost-Extended Format String Syntax. Wenn die Formatzeichenfolge eine leere Zeichenfolge ("") ist, ergibt eine Übereinstimmung kein Ergebnis für diese Teilzeichenfolge.

Siehe auch die RegExMatch Funktion.

Beispiele

// To remove any whitespace from a string:
RegExReplace(" t e st ss s", "\\s", "");
// Returns "testsss"

// To swap the order of sub-strings:
RegExReplace("abc(first)123(second)xyz",
             "(.*)(\\(.*\\))(.*)(\\(.*\\))(.*)",
             "\\1aaa\\4\\2\\3\\5");
// Returns "abcaaa(second)(first)123xyz"

// To pass backslashes in matches, multiple instances may be required.
// In the "r" example, three backslashes are used and then doubled.
// The first two backslashes convert into a single backslash,
// which then escapes the next backslash.
// All three backslashes are then doubled for Jitterbit script.
s = "test\\ing";  // "test\ing";
t = RegExReplace(s, "\\\\", "!");  // "test\ing" -> "test!ing"
r = RegExReplace(t, "!", "\\\\\\");  // "test!ing" ->  "test\\ing"

Replace

Deklaration

string Replace(string str, string old, string new)

Syntax

Replace(<str>, <old>, <new>)

Erforderliche Parameter

• str: Eine Zeichenfolge, die durchsucht wird und in der übereinstimmende Teilzeichenfolgen ersetzt werden

• old: Eine Zeichenfolge, die für den Vergleich verwendet wird

• new: Eine Zeichenfolge, die als Ersatz für gefundene Übereinstimmungen verwendet wird

Beschreibung

Durchsucht eine Zeichenfolge nach Teilzeichenfolgen, die dem Argument "old" entsprechen, und ersetzt eine übereinstimmende Teilzeichenfolge durch das Argument "new".

Für komplexere Such- und Ersetzvorgänge siehe die RegExReplace Funktion.

Beispiele

Replace("Montag Dienstag", "Tag", "Tag Nacht,");
// Gibt "Montag Nacht, Dienstag Nacht," zurück

Right

Deklaration

string Right(string str, int n)

Syntax

Right(<str>, <n>)

Erforderliche Parameter

• str: Eine Zeichenfolge

• n: Die Anzahl der Zeichen vom rechten Ende, die zurückgegeben werden sollen

Beschreibung

Gibt n Zeichen einer Zeichenfolge zurück, gezählt von rechts (dem Ende) einer Zeichenfolge.

Siehe auch die Funktionen Left und Mid.

Beispiele

Right("01234567890",4);
// Gibt "7890" zurück

RPad

Deklaration

string RPad(string s, int n)

Syntax

string RPad(string s, int n)

Erforderliche Parameter

• str: Ein String

• n: Die Anzahl der Zeichen vom rechten Ende, die zurückgegeben werden sollen

Beschreibung

Fügt rechts (am Ende) eines Strings Leerzeichen hinzu, bis der String n Zeichen enthält. Strings mit n oder mehr Zeichen werden auf n Zeichen gekürzt.

RPad(str, -n) ist dasselbe wie LPad(str, n). Siehe die Funktion LPad.

Beispiele

RPad("01234567",9);
// Gibt "01234567 " zurück

RPadChar

Deklaration

string RPadChar(string str, string padChar, int n)

Syntax

RPadChar(<str>, <padChar>, <n>)

Erforderliche Parameter

• str: Ein String
• padChar: Ein String, der zum Auffüllen von Zeichen verwendet wird; wenn mehr als ein Zeichen, wird das erste Zeichen verwendet
• n: Die Anzahl der Zeichen vom rechten Ende, die zurückgegeben werden sollen

Beschreibung

Fügt ein Auffüllzeichen rechts (am Ende) eines Strings hinzu, bis der String n Zeichen enthält. Strings mit n oder mehr Zeichen werden auf n Zeichen gekürzt.

RPadChar(str, " ", n) ist dasselbe wie RPad(str, n). Siehe die Funktion RPad.

Beispiele

RPadChar(1234567, "0", 10);
// Gibt "1234567000" zurück

RTrim

Deklaration

string RTrim(string str)

Syntax

RTrim(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Entfernt Leerzeichen (Leerzeichen, Tabs) von der rechten Seite (dem Ende) eines Strings und gibt die verbleibenden Zeichen zurück.

Beispiele

RTrim(" Hello World!  ");
// Returns " Hello World!"

RTrim("Hello World!    ");
// Removes the trailing tab character
// and returns "Hello World!"

RTrimChars

Deklaration

string RTrimChars(string str, string trimChars)

Syntax

RTrimChars(<str>, <trimChars>)

Erforderliche Parameter

• str: Ein String, der von der rechten Seite (dem Ende) beschnitten werden soll**
  
• trimChars:** Ein String von zu beschnittenden Zeichen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle nachfolgenden Zeichen in einem String vom Ende, die mit den beschnittenen Zeichen übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion testet jedes nachfolgende Zeichen eines Strings, beginnend an der rechten Kante, und prüft, ob es in den beschnittenen Zeichen gefunden wird. Wenn ja, wird es entfernt, und der Vorgang wird wiederholt, bis keine Übereinstimmung mehr vorliegt.

Dies kann verwendet werden, um andere Zeichen als die standardmäßigen Leerzeichen zu entfernen, wie zum Beispiel das Entfernen von nachfolgenden Doppelpunkten.

Siehe auch die Funktionen LTrimChars und TrimChars.

Beispiele

RTrimChars("::StartMsg :: Hello :: EndMsg::", ":");
// Returns "::StartMsg :: Hello :: EndMsg"

RTrimChars("// This is a comment //", " /");
// Returns "// This is a comment"

RTrimChars("// This is a comment //", "/");
// Returns "// This is a comment "

RTrimChars("// This is a comment //", " ");
// Returns "// This is a comment //"
// Returns the string unchanged as a space
// was not a trailing character

Split

Deklaration

array Split(string str, string delimiter)

Syntax

Split(<str>, <delimiter>)

Erforderliche Parameter

• str: Ein String, der aufgeteilt werden soll
• delimiter: Ein String, der als Trennzeichen zwischen den einzelnen Array-Elementen verwendet werden soll

Beschreibung

Teilt einen String mithilfe eines Trennzeichens und gibt das Ergebnis als Array zurück.

Das Ergebnis wird in einem Array zurückgegeben, dessen Größe der Anzahl der Trennzeichen plus eins entspricht. Wenn der Ausdruck mit dem Trennzeichen endet, ist die Array-Größe gleich der Anzahl der Trennzeichen (der letzte leere Wert wird ignoriert). Wenn der String keine Trennzeichen enthält, wird ein Array der Größe eins zurückgegeben, das den ursprünglichen String enthält.

Beispiele

arr = Split("Donald,Minnie,Goofy", ",");
donald = arr[0];
minnie = arr[1];
goofy = arr[2];

Split("Donald.,Minnie.,Goofy.,", ".,");
// Returns the array {Donald, Minnie, Goofy}

Dieses Beispiel konvertiert eine IP-Adresse ("10.6.10.1") in eine einzelne Ganzzahl (168167937):

// Logic: (first octet * 16777216) + (second octet * 65536) +
//   (third octet * 256) + (fourth octet)
ip = "10.6.10.1";
ipList = Split(ip, ".");
(Int(ipList[0]) * 16777216) + (Int(ipList[1]) * 65536) +
    (Int(ipList[2]) * 256) + (Int(ipList[3]));

SplitCSV

Deklaration

array Split(string str[, string delimiter, int qualifier])

Syntax

Split(<str>[, <delimiter>, <qualifier>])

Erforderliche Parameter

• str: Ein zu teilender String

Optionale Parameter

• delimiter: Ein String, der als Trennzeichen zwischen den einzelnen Array-Elementen verwendet wird
• qualifier: Ein String, der als Trennzeichen zwischen den einzelnen Array-Elementen verwendet wird

Beschreibung

Teilt einen im CSV-Format formatierten String und gibt ein Array mit den einzelnen Spaltenwerten zurück.

Standardmäßig ist das Trennzeichen ein Komma (,) und der String-Qualifier ist ein doppeltes Anführungszeichen ("). Dies kann geändert werden, indem die optionalen zweiten und dritten Argumente entsprechend angegeben werden.

Beispiele

arr = SplitCSV('"Donald","Minnie ""The Mouse""", Goofy');
donald = arr[0];
// Returns "Donald"
minnie = arr[1];
// Returns "Minnie ""The Mouse"""
goofy = arr[2];
// Returns "Goofy"

StringLength

Deklaration

int StringLength(string str)

array StringLength(array arr)

Syntax

StringLength(string str)

StringLength(array arr)

Erforderliche Parameter

• str: (Erste Form) Ein String

• arr: (Zweite Form) Ein Array

Beschreibung

Gibt die Länge eines Strings zurück.

Die Funktion gibt ein Array zurück, wenn das Argument ein Array ist, wobei jedes Element des zurückgegebenen Arrays die Länge des entsprechenden Elements des Argumentarrays ist. Die Length-Funktion gibt die Länge eines Arrays zurück, anstatt die Länge der einzelnen Elemente.

Beispiele

arr = {a="abcd", b="e"};

StringLength(arr);
// Returns the array {4,1}

Length(arr);
// Returns 2

ToLower

Deklaration

string ToLower(string str)

Syntax

ToLower(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Konvertiert alle ASCII-Großbuchstaben (A bis Z, ASCII 65 bis 90) in einem String in Kleinbuchstaben.

Beispiele

ToLower("Hello World!");
// Gibt "hello world!" zurück

ToProper

Deklaration

string ToProper(string str)

Syntax

ToProper(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Konvertiert einen String in die richtige Schreibweise (der erste Buchstabe jedes Wortes wird großgeschrieben). Dies unterscheidet sich von der Titel-Schreibweise, die nur ausgewählte und längere Wörter in einem String großschreibt.

s = "mccartney, paul";
s = Right( ToProper( " " + s), Length(s));

Beispiele

ToProper("bob dylan");
// Returns "Bob Dylan"
ToProper("arthur c. Clarke");
// Returns "Arthur C. Clarke"
ToProper("Peter o'toole");
// Returns "Peter O'Toole"

ToUpper

Deklaration

string ToUpper(string <str>)

Syntax

ToUpper(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Konvertiert alle ASCII-Kleinbuchstaben (a bis z, ASCII 97 bis 122) in einem String in Großbuchstaben.

Beispiele

ToUpper("Hello World!");
// Gibt "HELLO WORLD!" zurück

Trim

Deklaration

string Trim(string str)

Syntax

Trim(<str>)

Erforderliche Parameter

• str: Ein String

Beschreibung

Entfernt Leerzeichen am Anfang und Ende eines Strings und gibt die verbleibenden Zeichen zurück.

Beispiele

Trim(" Hello World! ");
// Gibt "Hello World!" zurück

TrimChars

Deklaration

string TrimChars(string str, string trimChars)

Syntax

TrimChars(<str>, <trimChars>)

Erforderliche Parameter

• str: Ein zu kürzender String
• trimChars: Ein String von zu entfernenden Zeichen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle führenden oder nachfolgenden Zeichen in einem String, die mit den Zeichen in den zu entfernenden Zeichen übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion testet jedes führende und nachfolgende Zeichen eines Strings und prüft, ob es in den zu entfernenden Zeichen gefunden wird. Wenn ja, wird es entfernt, und der Vorgang wird wiederholt, bis keine Übereinstimmungen mehr vorhanden sind.

Dies kann verwendet werden, um Zeichen außer den standardmäßigen Leerzeichen zu trimmen, wie zum Beispiel das Trimmen von Doppelpunkten.

Siehe auch die Funktionen LTrimChars und RTrimChars.

Beispiele

TrimChars("::StartMsg :: Hello :: EndMsg::", ":");
// Returns "StartMsg :: Hello :: EndMsg"

TrimChars("/* This is a comment */", " /*");
// Returns "This is a comment"

Truncate

Deklaration

string Truncate(string str, int firstChars, int lastChars)

Syntax

Truncate(<str>, <firstChars>, <lastChars>)

Erforderliche Parameter

• str: Ein String
• firstChars: Die Anzahl der Zeichen, die von links (dem Anfang) des Strings gelöscht werden sollen
• lastChars: Die Anzahl der Zeichen, die von rechts (dem Ende) des Strings gelöscht werden sollen

Beschreibung

Löscht firstChar Zeichen von links (dem Anfang) und lastChars Zeichen von rechts (dem Ende) eines Strings und gibt den verbleibenden String zurück.

Siehe auch die Funktionen Left und Right.

Beispiele

Truncate("a,b,c,", 2, 1);
// Gibt "b,c" zurück

URLDecode

Deklaration

string URLDecode(string url, string paramName)

Syntax

URLDecode(<url>, <paramName>)

Erforderliche Parameter

• url: Ein String, der eine URL enthält
• paramName: Der Name eines Parameters in der URL, dessen Wert zurückgegeben werden soll

Beschreibung

Analysiert einen URL-String und gibt den dekodierten Wert des URL-Parameters mit dem angegebenen Namen zurück. Die Groß- und Kleinschreibung des Namens wird ignoriert. Wenn der Name in den Parametern der URL nicht gefunden wird, wird ein leerer String ("") zurückgegeben.

Siehe auch die Funktionen ParseURL und URLEncode.

Beispiele

url = "http://hostname/user?email=john1990%40gmail.com&name=John%20Smith";
URLDecode(url, "name");
// Gibt "John Smith" zurück

URLEncode

Deklaration

string URLEncode(string str[, int encodingOption])

Syntax

URLEncode(<str>[, <encodingOption>])

Erforderliche Parameter

• url: Eine Zeichenkette, die einen Wert enthält, der gemäß den Regeln von RFC 1738 kodiert werden soll. Multibyte-Zeichen werden ebenfalls unterstützt.

Optionale Parameter

• encodingOption: Eine Ganzzahl (0 - 3), die die zu verwendende Kodierung angibt. Der Standardwert ist 0. Siehe die Liste unten.

Beschreibung

Kodiert eine Zeichenkette gemäß RFC 1738.

Gültige Werte für die optionale Kodierungsoption sind:

• 0: Standard-URL-Kodierung. Kodiert ASCII-Steuerzeichen, Nicht-ASCII-Zeichen, Multibyte-Zeichen, "reservierte" Zeichen und "unsichere" Zeichen. Dies ist die Standardkodierung, wenn die Option weggelassen wird.
• 1: Kodiert keine "unsicheren" Zeichen: " \< ;> ; # % { } | \ ^ \~ [ ] ` und das Leerzeichen
• 2: Kodiert keine "reservierten" Zeichen: ; / ? : @ & =
• 3: Kodiert keine "unsicheren" Zeichen und "reservierten" Zeichen

Diese Zeichen gelten als "sicher" und werden niemals kodiert: $ - _ . + ! * ' ( ) ,

Siehe auch die Funktionen ParseURL und URLDecode.

Beispiele

value1 = "FIRST#"; value2 = "<LAST>";
url = "http://hostname/get_doc?" +
    "name1=" + URLEncode(value1) +
    "&name2=" + URLEncode(value2);
// Returns
// http://hostname/get_doc?name1=FIRST%23&name2=%3CLAST%3E