Stringfunktionen in Jitterbit Studio

Stringfunktionen sind das Mittel zur Manipulation von Strings in Skripten.

CountSubString

Deklaration

int CountSubString(string str, string subStr)

Syntax

CountSubString(<str>, <subStr>)

Erforderliche Parameter

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

Beschreibung

Gibt an, wie oft ein Substring in einem String vorkommt.

Beispiele

CountSubString("Mississippi", "iss"); // Returns 2

DQuote

Deklaration

string DQuote(string str)

Syntax

DQuote(<str>)

Erforderliche Parameter

• str: Ein String, der in doppelte Anführungszeichen gesetzt werden soll

Beschreibung

Setzt einen String 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: Der Formatstring, der beim Formatieren des Strings verwendet werden soll
• de: Ein Datenelement; falls erforderlich wird es vor der Formatierung in einen String konvertiert

Beschreibung

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

Die Formatspezifikation ist dieselbe wie in den Datums- und Zeitfunktionen verwendet; siehe deren Abschnitt zu Formatstrings. Sie ähnelt der Standard-C-Bibliothek printf Formatspezifikation.

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 wie gewünscht ist. Der Aufruf der Format-Funktion muss der letzte Aufruf in einer Mapping-Formel sein, damit dieser der zugeordnete Wert ist.

Beispiele

Format("'%5d'", 2); // Returns "'    2'"

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 Substrings innerhalb eines Strings zurück.

Falls der Substring mehr als einmal im Hauptstring vorkommt, wird das dritte Argument (n) verwendet, um zu bestimmen, welche spezifische Instanz des Substrings von Interesse ist.

• Wenn n < 0, beginnt das Zählen der Instanzen vom Ende des Hauptstrings.
• Wenn |n| > die maximale Anzahl der Vorkommen des Substrings im Hauptstring, gibt die Funktion -1 zurück.

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

Zu berücksichtigende Spezialfälle:

• n = 0 gibt das gleiche Ergebnis zurück wie n = 1

• 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: Eine zu validierende Zeichenkette

Beschreibung

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

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 Zeichenkette
• n: Die Anzahl der Zeichen vom linken Ende, die zurückgegeben werden sollen

Beschreibung

Gibt n Zeichen einer Zeichenkette zurück, gezählt vom linken Ende (dem Anfang) einer Zeichenkette.

Siehe auch die Funktionen Mid und Right.

Beispiele

Left("01234567890", 4);
// Returns "0123"

LPad

Deklaration

string LPad(string str, int n)

Syntax

LPad(<str>, <n>)

Erforderliche Parameter

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

Beschreibung

Fügt Leerzeichen am linken Ende (am Anfang) einer Zeichenkette hinzu, bis die Zeichenkette n Zeichen enthält. Zeichenketten mit n oder mehr Zeichen werden auf n Zeichen gekürzt.

LPad(str, -n) ist das gleiche 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: Eine Zeichenkette
• padChar: Eine Zeichenkette, die zum Auffüllen von Zeichen verwendet werden soll; 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üllungszeichen am linken Ende (am Anfang) einer Zeichenkette hinzu, bis die Zeichenkette n Zeichen enthält. Zeichenketten mit n oder mehr Zeichen werden auf n Zeichen gekürzt.

LPadChar(str, " ", n) ist das gleiche 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: Eine Zeichenkette

Beschreibung

Entfernt Leerzeichen (Leerzeichen, Tabulatoren) vom linken Ende (vom Anfang) einer Zeichenkette 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: Eine Zeichenkette, die von links (vom Anfang) gekürzt werden soll
• trimChars: Eine Zeichenkette mit Kürzungszeichen, die abgeglichen werden sollen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle führenden Zeichen einer Zeichenkette von links (vom Anfang), die mit denen in den Kürzungszeichen übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion prüft jedes führende Zeichen einer Zeichenkette, beginnend am linken Rand, und sieht nach, ob es in den Kürzungszeichen vorhanden ist. Falls ja, wird es entfernt und der Vorgang wiederholt, bis es keine Übereinstimmung mehr gibt.

Dies kann verwendet werden, um andere Zeichen als die Standard-Leerzeichen zu kürzen, z. B. zum Kürzen führender 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: Eine Zeichenkette, aus der eine Teilzeichenkette extrahiert werden soll

• m: Die nullbasierte Startzeichenposition, ab der die Teilzeichenkette extrahiert werden soll

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

Beschreibung

Gibt einen Teil einer Zeichenkette zurück, beginnend mit dem Zeichen an Position m mit einer 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 mit einer URL zum Analysieren

Beschreibung

Analysiert eine URL-Zeichenkette und gibt ein Array mit dekodierten Werten zurück. Die Werte sind gekennzeichnet, sodass sie entweder nach Index oder nach Feldname abgerufen werden können.

Beim Abrufen von Werten aus dem Ergebnis wird die Groß-/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 mit Escape-Zeichen versehen.

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: Eine Zeichenkette, die abgeglichen werden soll

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

Optionale Parameter

• var1...varN: Ein oder mehrere Variablennamen, die den markierten Teilausdrücken des Ausdrucks entsprechen

Beschreibung

Gleicht einen regulären Ausdruck mit einer Eingabezeichenkette ab, speichert die markierten Teilausdrücke in Variablen und gibt die Anzahl der Übereinstimmungen zurück.

Gibt die Gesamtzahl der markierten Teilausdrücke zurück (die größer oder kleiner als die Anzahl der tatsächlich bereitgestellten Variablen sein kann). Alle zusätzlichen Übereinstimmungen, die die Anzahl der bereitgestellten Variablen überschreiten, werden verworfen. Wenn keine Übereinstimmungen vorhanden sind, wird -1 zurückgegeben.

Der reguläre Ausdruck folgt der Boost-Bibliothek für reguläre Ausdrücke. Es ist eine Variation der Perl-Syntax für reguläre Ausdrücke.

Unicode-Zeichen, einschließlich Symbole wie Emojis, müssen mit ihren Literalzeichen abgeglichen werden und nicht mit Unicode-Escape-Sequenzen. Beispielsweise erfasst der Bereich "[😀-🤯]" (U+1F600 bis U+1F92F) erfolgreich das Symbol 🤔 (U+1F914) 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 Zeichenkette, die durchsucht werden soll und in der alle übereinstimmenden Teilzeichenketten ersetzt werden

• exp: Der reguläre Ausdruck in der Boost-Bibliothek für reguläre Ausdrücke, der zum Abgleichen von Teilzeichenketten der Zeichenkette verwendet werden soll

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

Beschreibung

Ersetzt alle Teilzeichenketten in einer Zeichenkette, die einem Ausdruck entsprechen, und verwendet eine angegebene Formatierung zum Ersetzen jeder Teilzeichenkette. Alle Abschnitte der Zeichenkette, die nicht dem Ausdruck entsprechen, werden unverändert an die zurückgegebene Zeichenkette übergeben.

Der reguläre Ausdruck folgt der Boost-Bibliothek für reguläre Ausdrücke. Es ist eine Variation der Perl-Syntax für reguläre Ausdrücke.

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

Die Formatzeichenkette folgt der Boost-Extended Format String Syntax. Wenn die Formatzeichenkette eine leere Zeichenkette ("") ist, erzeugt eine Übereinstimmung kein Ergebnis für diese Teilzeichenkette.

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 Zeichenkette, die durchsucht wird und in der übereinstimmende Teilzeichenketten ersetzt werden

• old: Eine Zeichenkette, die für die Übereinstimmung verwendet wird

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

Beschreibung

Durchsucht eine Zeichenkette nach Teilzeichenketten, die dem Argument „old" entsprechen, und ersetzt eine übereinstimmende Teilzeichenkette durch das Argument „new".

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

Beispiele

Replace("Monday Tuesday", "day", "day night,");
// Returns "Monday night, Tuesday night,"

Right

Deklaration

string Right(string str, int n)

Syntax

Right(<str>, <n>)

Erforderliche Parameter

• str: Eine Zeichenkette

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

Beschreibung

Gibt n Zeichen einer Zeichenkette zurück, gezählt vom rechten Ende (dem Ende) einer Zeichenkette.

Siehe auch die Funktionen Left und Mid.

Beispiele

Right("01234567890",4);
// Returns "7890"

RPad

Deklaration

string RPad(string s, int n)

Syntax

string RPad(string s, int n)

Erforderliche Parameter

• str: Eine Zeichenkette

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

Beschreibung

Fügt Leerzeichen am rechten Ende einer Zeichenkette hinzu, bis die Zeichenkette n Zeichen enthält. Zeichenketten 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);
// Returns "01234567 "

RPadChar

Deklaration

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

Syntax

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

Erforderliche Parameter

• str: Eine Zeichenkette
• padChar: Eine Zeichenkette, die zum Auffüllen von Zeichen verwendet wird; bei mehr als einem Zeichen wird das erste Zeichen verwendet
• n: Die Anzahl der Zeichen vom rechten Ende, die zurückgegeben werden sollen

Beschreibung

Fügt ein Auffüllungszeichen am rechten Ende einer Zeichenkette hinzu, bis die Zeichenkette n Zeichen enthält. Zeichenketten 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);
// Returns "1234567000"

RTrim

Deklaration

string RTrim(string str)

Syntax

RTrim(<str>)

Erforderliche Parameter

• str: Eine Zeichenkette

Beschreibung

Entfernt Leerzeichen (Leerzeichen, Tabulatoren) von rechts (vom Ende) einer Zeichenkette 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: Eine Zeichenkette, die von rechts (vom Ende) gekürzt werden soll
• trimChars: Eine Zeichenkette mit Kürzungszeichen, die abgeglichen werden sollen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle nachfolgenden Zeichen einer Zeichenkette vom Ende, die mit denen in den Kürzungszeichen übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion testet jedes nachfolgende Zeichen einer Zeichenkette, beginnend von der rechten Kante, und prüft, ob es in den Kürzungszeichen vorhanden ist. Falls ja, wird es entfernt und der Vorgang wiederholt, bis es keine Übereinstimmung mehr gibt.

Dies kann verwendet werden, um andere Zeichen als die Standard-Leerzeichen zu kürzen, z. B. zum Kürzen 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: Eine Zeichenkette, die geteilt werden soll
• delimiter: Eine Zeichenkette, die als Trennzeichen zwischen den einzelnen Array-Elementen abgeglichen werden soll

Beschreibung

Teilt eine Zeichenkette mit einer Trennzeichenkette und gibt das Ergebnis als Array zurück.

Gibt das Ergebnis in einem Array mit einer Größe zurück, die der Anzahl der Trennzeichen plus eins entspricht. Wenn der Ausdruck mit dem Trennzeichen endet, entspricht die Array-Größe der Anzahl der Trennzeichen (der letzte leere Wert wird ignoriert). Wenn die Zeichenkette keine Trennzeichen enthält, wird ein Array der Größe eins zurückgegeben, das die ursprüngliche Zeichenkette 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: Eine Zeichenkette, die geteilt werden soll

Optionale Parameter

• delimiter: Eine Zeichenkette, die als Trennzeichen zwischen den einzelnen Array-Elementen abgeglichen werden soll
• qualifier: Eine Zeichenkette, die als Trennzeichen zwischen den einzelnen Array-Elementen abgeglichen werden soll

Beschreibung

Teilt eine CSV-formatierte Zeichenkette und gibt ein Array mit den einzelnen Spaltenwerten zurück.

Standardmäßig ist das Trennzeichen ein Komma (,) und der Zeichenketten-Qualifier ist ein doppeltes Anführungszeichen ("). Dies kann durch Angabe der optionalen zweiten und dritten Argumente geändert 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) Eine Zeichenkette

• arr: (Zweite Form) Ein Array

Beschreibung

Wenn das Argument eine Zeichenkette ist, gibt die Funktion die Länge der Zeichenkette zurück.

Wenn das Argument ein Array ist, gibt die Funktion ein Array zurück, bei dem jedes Element auf die Länge des entsprechenden Elements im Argument-Array gesetzt ist. Die Funktion Length gibt die Länge eines Arrays zurück, nicht 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: Eine Zeichenkette

Beschreibung

Konvertiert alle Großbuchstaben in einer Zeichenkette in Kleinbuchstaben.

Beispiele

ToLower("Hello World!");
// Returns "hello world!"

ToProper

Deklaration

string ToProper(string str)

Syntax

ToProper(<str>)

Erforderliche Parameter

• str: Eine Zeichenkette

Beschreibung

Konvertiert eine Zeichenkette in Großschreibung (der erste Buchstabe jedes Wortes wird großgeschrieben). Dies unterscheidet sich von der Titelschreibung, die nur ausgewählte und längere Wörter in einer Zeichenkette 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: Eine Zeichenkette

Beschreibung

Konvertiert alle Kleinbuchstaben in einer Zeichenkette in Großbuchstaben.

Beispiele

ToUpper("Hello World!");
// Returns "HELLO WORLD!"

Trim

Deklaration

string Trim(string str)

Syntax

Trim(<str>)

Erforderliche Parameter

• str: Eine Zeichenkette

Beschreibung

Entfernt Leerzeichen vom Anfang und Ende einer Zeichenkette und gibt die verbleibenden Zeichen zurück.

Beispiele

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

TrimChars

Deklaration

string TrimChars(string str, string trimChars)

Syntax

TrimChars(<str>, <trimChars>)

Erforderliche Parameter

• str: Eine zu kürzende Zeichenkette
• trimChars: Eine Zeichenkette mit Kürzungszeichen, die abgeglichen werden sollen; die Reihenfolge spielt keine Rolle

Beschreibung

Entfernt alle führenden oder nachfolgenden Zeichen in einer Zeichenkette, die mit denen in den Kürzungszeichen übereinstimmen, und gibt die verbleibenden Zeichen zurück.

Diese Funktion prüft jedes führende und nachfolgende Zeichen einer Zeichenkette und sieht, ob es in den Kürzungszeichen vorhanden ist. Falls ja, wird es entfernt und der Vorgang wiederholt, bis es keine Übereinstimmungen mehr gibt.

Dies kann verwendet werden, um andere Zeichen als die Standard-Leerzeichen zu kürzen, z. B. zum Kürzen 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: Eine Zeichenkette
• firstChars: Die Anzahl der Zeichen, die von links (vom Anfang) der Zeichenkette gelöscht werden sollen
• lastChars: Die Anzahl der Zeichen, die von rechts (vom Ende) der Zeichenkette gelöscht werden sollen

Beschreibung

Löscht firstChar Zeichen von links (vom Anfang) und lastChars Zeichen von rechts (vom Ende) einer Zeichenkette und gibt die verbleibende Zeichenkette zurück.

Siehe auch die Funktionen Left und Right.

Beispiele

Truncate("a,b,c,", 2, 1);
// Returns "b,c"

URLDecode

Deklaration

string URLDecode(string url, string paramName)

Syntax

URLDecode(<url>, <paramName>)

Erforderliche Parameter

• url: Eine Zeichenkette mit einer URL
• paramName: Der Name eines Parameters in der URL, dessen Wert zurückgegeben werden soll

Beschreibung

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

Siehe auch die Funktionen ParseURL und URLEncode.

Beispiele

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

URLEncode

Deklaration

string URLEncode(string str[, int encodingOption])

Syntax

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

Erforderliche Parameter

• url: Eine Zeichenkette mit einem Wert, der nach den Regeln von RFC 1738 kodiert werden soll. Mehrbyte-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 nach RFC 1738.

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

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

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

Siehe auch die Funktionen ParseURL und URLDecode.

Zur Fehlerbehebung siehe URLEncode codiert bestimmte „sichere" oder Multibyte-Zeichen nicht im Leitfaden zur Fehlerbehebung bei Operationen.

<javascript>
$my_username = "$Example+User";
$my_password = "*******";
$loginBody = 'username=' + encodeURIComponent($my_username) + '&password=' + encodeURIComponent($my_password);
</javascript>

// Returns "username=%24Example%2BUser&password=*******"

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