Zeichenfolgenfunktionen in Jitterbit 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 werden soll

Beschreibung

Gibt die Anzahl der Vorkommen eines Teilstrings 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 zu doppelt zu zitierende Zeichenfolge

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 eine Zeichenkette im durch einen Format-String angegebenen Format zurück.

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

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: Eine zu durchsuchende Zeichenkette
• subStr: Die Zeichenkette, mit der gesucht werden soll

Optionale Parameter

• n: Die spezifische Instanz von Interesse, falls mehr als ein Treffer vorhanden ist

Beschreibung

Gibt die Position eines Teilstrings innerhalb einer Zeichenkette zurück.

In Fällen, in denen der Teilstring mehr als einmal in der Hauptzeichenkette erscheint, wird das dritte Argument (n) verwendet, um zu bestimmen, welche spezifische Instanz des Teilstrings von Interesse ist.

• Wenn n < 0, beginnt die Instanzzählung vom Ende der Hauptzeichenkette.
• Wenn |n| > der maximalen Anzahl von Vorkommen, die der Teilstring in der Hauptzeichenkette hat, gibt die Funktion -1 zurück.

Andernfalls gibt die Funktion die Position des ersten Zeichens des Teilstrings innerhalb der Hauptzeichenkette zurück (beginnend bei Position 0).

Besondere Fälle, die zu beachten sind:

• n = 0 gibt dasselbe Ergebnis wie n = 1 zurück

• Wenn subStr eine leere Zeichenkette ("") 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: Ein zu validierender String

Beschreibung

Gibt true zurück, wenn jedes Zeichen in einem String 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: Ein String
• n: Die Anzahl der Zeichen, die vom linken Ende zurückgegeben werden sollen

Beschreibung

Gibt n Zeichen eines Strings zurück, beginnend von links (dem Anfang) eines Strings.

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 RPad-Funktion.

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, 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 LPad-Funktion.

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 Trimmzeichen, die übereinstimmen sollen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle führenden Zeichen in einem String von links (dem Anfang), die mit den Trimmzeichen ü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 Trimmzeichen 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 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 der Teilstring extrahiert werden soll

• 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: Ein String, der eine URL zum Parsen enthält

Beschreibung

Parst einen URL-String 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: Ein String, der in einfache Anführungszeichen gesetzt werden soll

Beschreibung

Setzt einen String 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 mit verglichen werden soll

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

Optionale Parameter

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

Beschreibung

Vergleicht einen regulären Ausdruck mit einer Eingabezeichenfolge, 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 übereinstimmen. 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: Ein String, der durchsucht wird und in dem übereinstimmende Teilstrings ersetzt werden

• exp: Der reguläre Ausdruck in der Boost regulären Ausdrucksbibliothek-Syntax, der verwendet wird, um nach Teilstrings des Strings zu suchen

• format: Ein Format-String in der Boost-Extended Format String Syntax

Beschreibung

Ersetzt alle Teilstrings in einem String, die einem Ausdruck entsprechen, wobei ein spezifiziertes Format verwendet wird, um jeden Teilstring zu ersetzen. Alle Abschnitte des Strings, die nicht mit dem Ausdruck übereinstimmen, werden unverändert in den zurückgegebenen String übergeben.

Der reguläre Ausdruck folgt der Boost regulären Ausdrucksbibliothek-Syntax. Es handelt sich um eine Variation der Perl regulären Ausdruckssyntax.

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.

Der Format-String folgt der Boost-Extended Format String Syntax. Wenn der Format-String ein leerer String ("") ist, ergibt eine Übereinstimmung kein Ergebnis für diesen Teilstring.

Siehe auch die Funktion RegExMatch.

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 ü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 Ersetzungsoperationen siehe die Funktion RegExReplace.

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 vom rechten Ende (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 Leerzeichen am rechten Ende eines Strings hinzu, bis der String n Zeichen enthält. Strings, die n oder mehr Zeichen enthalten, 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 der Zeichen verwendet wird; wenn mehr als ein Zeichen vorhanden ist, wird das erste Zeichen verwendet
• n: Die Anzahl der Zeichen vom rechten Ende, die zurückgegeben werden sollen

Beschreibung

Fügt ein Auffüllzeichen am rechten Ende eines Strings hinzu, bis der String n Zeichen enthält. Strings, die n oder mehr Zeichen enthalten, 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 übereinstimmen sollen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle nachfolgenden Zeichen in einem String vom Ende, die mit den beschnittenden 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 beschnittenden 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 übereinstimmen soll

Beschreibung

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

Gibt das Ergebnis in einem Array zurück, 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("Hallo Welt!");
// Gibt "hallo welt!" 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>)

Required parameters

• str: Ein String

Description

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

Examples

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

Trim

Declaration

string Trim(string str)

Syntax

Trim(<str>)

Required parameters

• str: Ein String

Description

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

Examples

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

TrimChars

Declaration

string TrimChars(string str, string trimChars)

Syntax

TrimChars(<str>, <trimChars>)

Required parameters

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

Description

Entfernt alle führenden oder nachfolgenden Zeichen in einem String, die mit den Zeichen in den Trim-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 Trim-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 zu trimmen, die nicht die standardmäßigen Leerzeichen sind, wie zum Beispiel Doppelpunkte.

Siehe auch die Funktionen LTrimChars und RTrimChars.

Examples

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.

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, "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