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 wird

Beschreibung

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

Beispiele

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

[Zurück nach oben]

`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

Hinweis

Das äußere Paar von doppelten Anführungszeichen in den obigen Beispielen ist die Kennzeichnung eines Zeichenfolgendatentyps und wird nicht als Teil der Zeichenfolge selbst zurückgegeben.

[Zurück nach oben]

`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

[Zurück nach oben]

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

In Fällen, in denen der Teilstring mehr als einmal im Hauptstring 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 des Hauptstrings.
Wenn |n| > der maximale Anzahl der Vorkommen des Teilstrings im Hauptstring, gibt die Funktion -1 zurück.

Andernfalls gibt die Funktion die Position des ersten Zeichens des Teilstrings innerhalb des Hauptstrings 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 ein leerer String ("") 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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `IsValidString` {: #stringfunctions-isvalidstring }

### Deklaration {: #declaration }

bool IsValidString(string str)

### Syntax {: #syntax }

IsValidString()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein zu validierender String

### Beschreibung {: #description }

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 {: #examples }

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)

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Left` {: #stringfunctions-left }

### Deklaration {: #declaration }

string Left(string str, int n)

### Syntax {: #syntax }

Left(, )

#### Erforderliche Parameter {: #required-parameters }

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

### Beschreibung {: #description }

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

Siehe auch die Funktionen `Mid` und `Right`.

!!! note "Hinweis"
    Wenn der String ein numerischer String ist, der mit einer führenden Null beginnt, muss er in Anführungszeichen gesetzt werden, da er sonst als Ganzzahl interpretiert wird und ein anderer Startzeichenindex resultieren kann.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `LPad` {: #stringfunctions-lpad }

### Deklaration {: #declaration }

string LPad(string str, int n)

### Syntax {: #syntax }

LPad(, )

#### Erforderliche Parameter {: #required-parameters }

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

### Beschreibung {: #description }

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 {: #examples }

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

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `LPadChar` {: #stringfunctions-lpadchar }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

LPadChar(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`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 {: #description }

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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `LTrim` {: #stringfunctions-ltrim }

### Deklaration {: #declaration }

string LTrim(string str)

### Syntax {: #syntax }

LTrim()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

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

### Beispiele {: #examples }

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

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `LTrimChars` {: #stringfunctions-ltrimchars }

### Deklaration {: #declaration }

string LTrimChars(string str, string trimChars)

### Syntax {: #syntax }

LTrimChars(, )

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein zu bearbeitender String von links (dem Anfang) 
-   **`trimChars`:** Ein String von zu entfernenden Zeichen, die übereinstimmen; die Reihenfolge spielt keine Rolle

### Beschreibung {: #description }

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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Mid` {: #stringfunctions-mid }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

Mid(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`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 {: #description }

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`.

!!! note "Hinweis"
    Wenn der String ein numerischer String ist, der mit einer führenden Null beginnt, muss er in Anführungszeichen gesetzt werden, da er sonst als Ganzzahl interpretiert wird und ein anderer Startzeichenindex resultieren kann.

### Beispiele {: #examples }

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"

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `ParseURL` {: #stringfunctions-parseurl }

### Deklaration {: #declaration }

array ParseURL(string url)

### Syntax {: #syntax }

ParseURL()

#### Erforderliche Parameter {: #required-parameters }

-   **`url`:** Ein String, der eine URL zum Parsen enthält

### Beschreibung {: #description }

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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>




## `Quote` {: #stringfunctions-quote }

### Deklaration {: #declaration }

string Quote(string str)

### Syntax {: #syntax }

Quote()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String, der in einfache Anführungszeichen gesetzt werden soll

### Beschreibung {: #description }

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

### Beispiele {: #examples }

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

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

!!! note "Hinweis"
    Das äußere Paar von doppelten Anführungszeichen in den obigen Beispielen ist die Kennzeichnung eines String-Datentyps und wird nicht als Teil des Strings selbst zurückgegeben.

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `RegExMatch` {: #stringfunctions-regexmatch }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

RegExMatch(, [, ,... ])

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String, der mit verglichen werden soll

-   **`exp`:** Ein regulärer Ausdruck, der aus Gruppen besteht

#### Optionale Parameter {: #optional-parameters }

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

### Beschreibung {: #description }

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](http://www.boost.org/doc/libs/release/libs/regex/). Es ist [eine Variation der Perl-Regulärer-Ausdruck-Syntax](https://www.boost.org/doc/libs/1_59_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html).

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.

!!! note "Hinweis"
    Reguläre Ausdrücke müssen die gesamte Eingabezeichenfolge abdecken, um zur Gesamtzahl der Übereinstimmungen zu zählen. Wenn beispielsweise `"My input string"` als Eingabezeichenfolge bereitgestellt wird, gibt die Verwendung von `"^My"` als regulären Ausdruck `-1` zurück. Die Verwendung von `"^My.*"` gibt `0` zurück, was darauf hinweist, dass eine Übereinstimmung gefunden wurde, ohne dass ein Teil-Ausdruck vorhanden ist. Weitere Informationen finden Sie in der [Boost `regex_match`](https://www.boost.org/doc/libs/1_82_0/libs/regex/doc/html/boost_regex/ref/regex_match.html) Dokumentation.

!!! warning "Warnung"
    Übereinstimmungen von einstelligen numerischen Zeichenfolgen (wie `RegExMatch("0", "(^[0-9]+$)")`) werden mit Agenten der Version 11.38 und früher nicht korrekt validiert.

Siehe auch die Funktion `RegExReplace`.

### Beispiele {: #examples }

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.

!!! note "Hinweis"
    `"\"` (Backslash) muss in literalen Zeichenfolgen escaped werden, da es das Escape-Zeichen ist. Um einen `"\"` zu verwenden, verwenden Sie einen doppelten Backslash: `"\\"`.

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `RegExReplace` {: #stringfunctions-regexreplace }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

RegExReplace(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String, der durchsucht wird und in dem übereinstimmende Teilstrings ersetzt werden

-   **`exp`:** Der reguläre Ausdruck in der [Boost-Regulärer-Ausdruck-Bibliothek-Syntax](http://www.boost.org/doc/libs/release/libs/regex/), der verwendet wird, um nach Teilstrings des Strings zu suchen

-   **`format`:** Ein Format-String in der [Boost-Extended Format String Syntax](http://www.boost.org/doc/libs/1_66_0/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html)

### Beschreibung {: #description }

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ärer-Ausdruck-Bibliothek-Syntax](http://www.boost.org/doc/libs/release/libs/regex/). Es handelt sich um eine [Variation der Perl-Regulärer-Ausdruck-Syntax](https://www.boost.org/doc/libs/1_59_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html).

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](http://www.boost.org/doc/libs/1_66_0/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html). Wenn der Format-String ein leerer String (`""`) ist, ergibt eine Übereinstimmung kein Ergebnis für diesen Teilstring.

Siehe auch die Funktion `RegExMatch`.

### Beispiele {: #examples }

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

!!! note "Hinweis"
    `"\"` (Backslash) muss in literalen Zeichenfolgen escaped werden, da es das Escape-Zeichen ist. Um einen `"\"` zu verwenden, verwenden Sie einen doppelten Backslash: `"\\"`.

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Replace` {: #stringfunctions-replace }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

Replace(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`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 {: #description }

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

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

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Right` {: #stringfunctions-right }

### Deklaration {: #declaration }

string Right(string str, int n)

### Syntax {: #syntax }

Right(, )

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Eine Zeichenfolge

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

### Beschreibung {: #description }

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

Siehe auch die Funktionen `Left` und `Mid`.

!!! note "Hinweis"
    Wenn die Zeichenfolge eine numerische Zeichenfolge ist, die mit einer führenden Null beginnt, muss sie in Anführungszeichen gesetzt werden, da sie sonst als Ganzzahl interpretiert wird und ein anderer Startzeichenindex resultieren kann.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Back to top]](#top)

</div>


## `RPad` {: #stringfunctions-rpad }

### Deklaration {: #declaration }

string RPad(string s, int n)

### Syntax {: #syntax }

string RPad(string s, int n)

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

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

### Beschreibung {: #description }

Fügt Leerzeichen am rechten Ende eines Strings 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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Back to top]](#top)

</div>


## `RPadChar` {: #stringfunctions-rpadchar }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

RPadChar(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`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 {: #description }

Fügt ein Auffüllzeichen am rechten 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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Back to top]](#top)

</div>


## `RTrim` {: #stringfunctions-rtrim }

### Deklaration {: #declaration }

string RTrim(string str)

### Syntax {: #syntax }

RTrim()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

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

### Beispiele {: #examples }

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

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `RTrimChars` {: #stringfunctions-rtrimchars }

### Deklaration {: #declaration }

string RTrimChars(string str, string trimChars)

### Syntax {: #syntax }

RTrimChars(, )

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String, der von der rechten Seite (dem Ende) gekürzt werden soll
-   **`trimChars`:** Ein String von zu vergleichenden Kürzungszeichen; die Reihenfolge spielt keine Rolle

### Beschreibung {: #description }

Entfernt alle nachfolgenden Zeichen in einem String vom Ende, die mit den Kürzungszeichen ü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 Kürzungszeichen 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 kürzen, wie zum Beispiel das Kürzen von nachfolgenden Doppelpunkten.

Siehe auch die Funktionen `LTrimChars` und `TrimChars`.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Split` {: #stringfunctions-split }

### Deklaration {: #declaration }

array Split(string str, string delimiter)

### Syntax {: #syntax }

Split(, )

#### Erforderliche Parameter {: #required-parameters }

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

### Beschreibung {: #description }

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 {: #examples }

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]));

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `SplitCSV` {: #stringfunctions-splitcsv }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

Split([, , ])

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein zu teilender String

#### Optionale Parameter {: #optional-parameters }

-   **`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 {: #description }

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.

!!! note "Hinweis"
    Die optionalen Parameter (Trennzeichen und Qualifier) können mit einer Ganzzahl angegeben werden, die dem ASCII-Code des Trennzeichen- oder Qualifier-Zeichens entspricht.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `StringLength` {: #stringfunctions-stringlength }

### Deklaration {: #declaration }

int StringLength(string str)

array StringLength(array arr)

### Syntax {: #syntax }

StringLength(string str)

StringLength(array arr)

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** (Erste Form) Ein String

-   **`arr`:** (Zweite Form) Ein Array

### Beschreibung {: #description }

Wenn das Argument ein String ist, gibt die Funktion die Länge des Strings 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 `Length`-Funktion gibt die Länge eines Arrays zurück, anstatt die Länge der einzelnen Elemente.

!!! note "Hinweis"
    Bei der Verwendung von Agenten der Version 12.7 und höher unterstützt die Funktion UTF-8-Zeichen. Setzen Sie [`jitterbit.script.string.utf8size`](/de/integration-studio/design/variables/jitterbit/scripting-jitterbit-variables/#jitterbitscriptstringutf8size) auf `false`, um stattdessen die Byteanzahl zu verwenden. Die Byteanzahl wird standardmäßig bei Agenten der Version 12.6 und früher verwendet.

### Beispiele {: #examples }

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

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

Length(arr); // Returns 2

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>




## `ToLower` {: #stringfunctions-tolower }

### Deklaration {: #declaration }

string ToLower(string str)

### Syntax {: #syntax }

ToLower()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

Konvertiert alle Großbuchstaben in einem String in Kleinbuchstaben.

!!! important "Wichtig"
    Die Unterstützung für mehrbyteige Zeichen erfordert die Agenten-Version 12.7 oder höher.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `ToProper` {: #stringfunctions-toproper }

### Deklaration {: #declaration }

string ToProper(string str)

### Syntax {: #syntax }

ToProper()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

Konvertiert einen String in die korrekte 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.

!!! important "Wichtig"
    Die Unterstützung für mehrbyteige Zeichen erfordert die Agenten-Version 12.7 oder höher.

!!! warning "Warnung"
    Die Funktion `ToProper` ist so gestaltet, dass Namen wie `"mccartney"`, die mit `"mc"` beginnen, nur dann korrekt in `"McCartney"` umgewandelt werden, wenn das Wort von einem Leerzeichen gefolgt wird. Um einen String, der mit `"mc"` beginnt, wie `"mccartney, paul"` korrekt in `"McCartney, Paul"` umzuwandeln, verwenden Sie Code wie diesen, um ein vorhergehendes Leerzeichen hinzuzufügen und es dann sofort zu entfernen:

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

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Nach oben]](#top)

</div>


## `ToUpper` {: #stringfunctions-toupper }

### Deklaration {: #declaration }

string ToUpper(string )

### Syntax {: #syntax }

ToUpper()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

Konvertiert alle Kleinbuchstaben in einem String in Großbuchstaben.

!!! important "Wichtig"
    Die Unterstützung für mehrbyte Zeichen erfordert die Agenten-Version 12.7 oder höher.

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Nach oben]](#top)

</div>


## `Trim` {: #stringfunctions-trim }

### Deklaration {: #declaration }

string Trim(string str)

### Syntax {: #syntax }

Trim()

#### Erforderliche Parameter {: #required-parameters }

-   **`str`:** Ein String

### Beschreibung {: #description }

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

### Beispiele {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Nach oben]](#top)

</div>


## `TrimChars` {: #stringfunctions-trimchars }

### Deklaration {: #declaration }

string TrimChars(string str, string trimChars)

### Syntax {: #syntax }

TrimChars(, )

#### Erforderliche Parameter {: #required-parameters }

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

### Beschreibung {: #description }

Entfernt alle führenden oder nachfolgenden Zeichen in einem String, die mit 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 trimmenden Zeichen gefunden wird. Wenn dies der Fall ist, wird es entfernt, und der Prozess 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 das Trimmen von Doppelpunkten.

Siehe auch die Funktionen `LTrimChars` und `RTrimChars`.

### Beispiele {: #examples }

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

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `Truncate` {: #stringfunctions-truncate }

### Deklaration {: #declaration }

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

### Syntax {: #syntax }

Truncate(, , )

#### Erforderliche Parameter {: #required-parameters }

-   **`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 {: #description }

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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>


## `URLDecode` {: #stringfunctions-urldecode }

### Deklaration {: #declaration }

string URLDecode(string url, string paramName)

### Syntax {: #syntax }

URLDecode(, )

#### Erforderliche Parameter {: #required-parameters }

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

### Beschreibung {: #description }

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 {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Zurück nach oben]](#top)

</div>




## `URLEncode` {: #stringfunctions-urlencode }

### Deklaration {: #declaration }

string URLEncode(string str[, int encodingOption])

### Syntax {: #syntax }

URLEncode([, ])

#### Erforderliche Parameter {: #required-parameters }

-   **`url`:** Eine Zeichenkette, die einen Wert enthält, der gemäß den Regeln von [RFC 1738](https://tools.ietf.org/html/rfc1738) kodiert werden soll. Mehrbyte-Zeichen werden ebenfalls unterstützt.

#### Optionale Parameter {: #optional-parameters }

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

### Beschreibung {: #description }

Kodiert eine Zeichenkette gemäß [RFC 1738](https://tools.ietf.org/html/rfc1738).

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 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`.

!!! important "Wichtig"
    Die Unterstützung für Mehrbyte-Zeichen erfordert die Agenten-Version 12.4 oder höher.

    Wenn Sie "sichere" Zeichen oder Zeichen kodieren müssen, die unerwartete Kodierungsergebnisse liefern, verwenden Sie die JavaScript-Funktionen `encodeURI` oder `encodeURIComponent`:

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

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

### Beispiele {: #examples }

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

[Zurück nach oben]