Funciones de cadena en Jitterbit Studio

Las funciones de cadena son el mecanismo para la manipulación de cadenas en scripts.

`CountSubString`

Declaración

int CountSubString(string str, string subStr)

Sintaxis

CountSubString(<str>, <subStr>)

Parámetros requeridos

str: Una cadena a ser buscada
subStr: La cadena con la que se busca

Descripción

Devuelve el número de veces que una subcadena aparece en una cadena.

Ejemplos

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

[Volver al inicio]

`DQuote`

Declaración

string DQuote(string str)

Sintaxis

DQuote(<str>)

Parámetros requeridos

str: Una cadena a ser entrecomillada

Descripción

Coloca una cadena entre comillas dobles y devuelve el resultado. Las comillas dobles incrustadas no se escapan.

Ejemplos

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

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

Nota

El par exterior de comillas dobles en los ejemplos anteriores es la indicación de un tipo de dato de cadena y no se devuelve como parte de la cadena misma.

[Volver al inicio]

`Format`

Declaración

string Format(string formatStr, type de)

Sintaxis

Format(<formatStr>, <de>)

Parámetros requeridos

formatStr: La cadena de formato que se utilizará al formatear la cadena
de: Un elemento de datos; si es necesario, se convertirá a una cadena antes de ser formateado

Descripción

Devuelve una cadena en el formato especificado por una cadena de formato.

La especificación de formato es la misma que se utiliza en las Funciones de fecha y hora; consulte su sección sobre cadenas de formato. Es similar a la especificación de formato printf de la biblioteca estándar de C.

Esta función se puede utilizar para establecer el formato de salida para un objetivo. Es útil cuando el formato de salida predeterminado de Jitterbit para un tipo de dato (como fecha o doble) no es el deseado. La llamada a la función Format debe ser la última llamada en una fórmula de mapeo para que sea el valor mapeado.

Ejemplos

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

[Volver arriba]

`Índice`

Declaración

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

Sintaxis

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

Parámetros requeridos

str: Una cadena a buscar
subStr: La cadena con la que buscar

Parámetros opcionales

n: La instancia específica de interés si hay más de una coincidencia

Descripción

Devuelve la posición de una subcadena dentro de una cadena.

En los casos en que la subcadena aparece más de una vez en la cadena principal, se utiliza el tercer argumento (n) para determinar qué instancia específica de la subcadena es de interés.

Si n < 0, el conteo de instancias comienza desde el final de la cadena principal.
Si |n| > el número máximo de veces que la subcadena aparece en la cadena principal, la función devuelve -1.

De lo contrario, la función devuelve la posición del primer carácter de la subcadena dentro de la cadena principal (comenzando en la posición 0).

Casos especiales a considerar:

n = 0 devuelve el mismo resultado que n = 1
Si subStr es una cadena vacía (""):
- n >= 0 siempre devuelve 0
- n < 0 siempre devuelve Length(str)

Ejemplos

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

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

bool IsValidString(string str)

### Sintaxis {: #syntax }

IsValidString()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que debe ser validada

### Descripción {: #description }

Devuelve verdadero si cada carácter en una cadena es válido. Los caracteres válidos son los códigos ASCII del 32 al 126 inclusive y cualquiera de los caracteres de salto de línea (LF), retorno de carro (CR) o tabulación (TAB).

### Ejemplos {: #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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

string Left(string str, int n)

### Sintaxis {: #syntax }

Left(, )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena
-   **`n`:** El número de caracteres desde el extremo izquierdo que se devolverán

### Descripción {: #description }

Devuelve `n` caracteres de una cadena, contando desde la izquierda (el principio) de una cadena.

Véase también las funciones `Mid` y `Right`.

!!! note "Nota"
    Si la cadena es una cadena numérica que comienza con un cero a la izquierda, debe estar entre comillas o se interpretará como un entero y puede resultar en un índice de carácter inicial diferente.

### Ejemplos {: #examples }

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

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

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

string LPad(string str, int n)

### Sintaxis {: #syntax }

LPad(, )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena
-   **`n`:** El número de caracteres desde el extremo izquierdo que se devolverán

### Descripción {: #description }

Agrega espacios a la izquierda (el principio) de una cadena hasta que la cadena contenga `n` caracteres. Las cadenas que contienen `n` o más caracteres se truncarán a `n` caracteres.

`LPad(str, -n)` es lo mismo que `RPad(str, n)`. Consulta la función `RPad`.

### Ejemplos {: #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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

LPadChar(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena
-   **`padChar`:** Una cadena que se utilizará para rellenar caracteres; si hay más de un carácter, se utiliza el primer carácter
-   **`n`:** El número de caracteres desde el extremo izquierdo que se devolverán

### Descripción {: #description }

Agrega un carácter de relleno a la izquierda (el principio) de una cadena hasta que la cadena contenga `n` caracteres. Las cadenas que contienen `n` o más caracteres se truncarán a `n` caracteres.

`LPadChar(str, " ", n)` es lo mismo que `LPad(str, n)`. Consulta la función `LPad`.

### Ejemplos {: #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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

string LTrim(string str)

### Sintaxis {: #syntax }

LTrim()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

### Descripción {: #description }

Elimina los espacios en blanco (espacios, tabulaciones) desde la izquierda (el principio) de una cadena y devuelve los caracteres restantes.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string LTrimChars(string str, string trimChars)

### Sintaxis {: #syntax }

LTrimChars(, )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se va a recortar desde la izquierda (el principio)
-   **`trimChars`:** Una cadena de caracteres de recorte que se deben coincidir; el orden no importa

### Descripción {: #description }

Elimina cualquier carácter inicial en una cadena desde la izquierda (el principio) que coincida con los caracteres de recorte y devuelve los caracteres restantes.

Esta función prueba cada carácter inicial de una cadena, comenzando en el borde izquierdo, y verifica si se encuentra en los caracteres de recorte. Si es así, se elimina y el proceso se repite hasta que ya no haya coincidencias.

Esto se puede usar para recortar caracteres distintos de los caracteres de espacio en blanco predeterminados, como recortar dos puntos iniciales.

Véase también las funciones `RTrimChars` y `TrimChars`.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

Mid(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena de la cual extraer una subcadena

-   **`m`:** La posición del carácter inicial basada en cero para comenzar a extraer la subcadena

-   **`n`:** La longitud (número de caracteres) de la subcadena que se va a extraer

### Descripción {: #description }

Devuelve una porción de una cadena, comenzando con el carácter en la posición `m` por una longitud de `n` caracteres.

Véase también las funciones `Left` y `Right`.

!!! note "Nota"
    Si la cadena es una cadena numérica que comienza con un cero inicial, debe estar entre comillas o se interpretará como un entero y puede resultar en un índice de carácter inicial diferente.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

array ParseURL(string url)

### Sintaxis {: #syntax }

ParseURL()

#### Parámetros requeridos {: #required-parameters }

-   **`url`:** Una cadena que contiene una URL para analizar

### Descripción {: #description }

Analiza una cadena de URL y devuelve un array de valores decodificados. Los valores están etiquetados para que se puedan recuperar ya sea por índice o por nombre de campo.

Al recuperar valores del resultado, se ignora el caso del nombre de campo. Ver también las funciones `URLDecode` y `URLEncode`.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>




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

### Declaración {: #declaration }

string Quote(string str)

### Sintaxis {: #syntax }

Quote()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se debe poner entre comillas simples

### Descripción {: #description }

Coloca una cadena entre comillas simples y devuelve el resultado. Las comillas simples incrustadas no se escapan.

### Ejemplos {: #examples }

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

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

!!! note "Nota"
    El par externo de comillas dobles en los ejemplos anteriores indica un tipo de dato de cadena y no se devuelve como parte de la cadena misma.

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

RegExMatch(, [, ,... ])

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se debe comparar

-   **`exp`:** Una expresión regular que consiste en grupos

#### Parámetros opcionales {: #optional-parameters }

-   **`var1...varN`:** Uno o más nombres de variables, que se asignarán a las subexpresiones marcadas de la expresión

### Descripción {: #description }

Compara una expresión regular con una cadena de entrada, almacena las subexpresiones marcadas en variables y devuelve el número de coincidencias.

Devuelve el número total de subexpresiones marcadas (que podría ser más o menos que el número de variables realmente suministradas). Cualquier coincidencia adicional que exceda el número de variables suministradas se descarta. Si no hay coincidencias, se devuelve `-1`.

La expresión regular sigue la [sintaxis de la biblioteca de expresiones regulares de Boost](http://www.boost.org/doc/libs/release/libs/regex/). Es [una variación de la sintaxis de expresiones regulares de Perl](https://www.boost.org/doc/libs/1_59_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html).

Los caracteres Unicode, incluidos símbolos como emoji, deben coincidirse utilizando sus caracteres literales y no utilizando secuencias de escape Unicode. Por ejemplo, el rango `"[😀-🤯]"` (U+1F600 a U+1F92F) captura con éxito el símbolo 🤔 (U+1F914) en el medio.

!!! note "Nota"
    Las expresiones regulares deben cubrir toda la cadena de entrada para contar hacia el número total de coincidencias. Por ejemplo, si se suministra `"My input string"` como la cadena de entrada, usar `"^My"` como la expresión regular devolverá `-1`. Usar `"^My.*"` devolverá `0`, indicando que se encontró una coincidencia sin una subexpresión. Consulte la documentación de [Boost `regex_match`](https://www.boost.org/doc/libs/1_82_0/libs/regex/doc/html/boost_regex/ref/regex_match.html) para más información.

!!! warning "Advertencia"
    Las coincidencias de cadenas numéricas de un solo dígito (como `RegExMatch("0", "(^[0-9]+$)")`) no se validan correctamente con versiones de agentes 11.38 y anteriores.

Consulte también la función `RegExReplace`.

### Ejemplos {: #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 "Nota"
    `"\"` (barra invertida) debe ser escapada en cadenas literales ya que es el carácter de escape. Para usar un `"\"`, use una barra invertida doble: `"\\"`.

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

RegExReplace(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se buscará y tendrá cualquier subcadena coincidente reemplazada

-   **`exp`:** La expresión regular en la [sintaxis de la biblioteca de expresiones regulares Boost](http://www.boost.org/doc/libs/release/libs/regex/) que se utilizará para coincidir con subcadenas de la cadena

-   **`format`:** Una cadena de formato en la [Sintaxis de Cadena de Formato Extendida de Boost](http://www.boost.org/doc/libs/1_66_0/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html)

### Descripción {: #description }

Reemplaza todas las subcadenas en una cadena que coinciden con una expresión, utilizando un formato especificado para reemplazar cada subcadena. Cualquier sección de la cadena que no coincida con la expresión se pasa a la cadena devuelta sin cambios.

La expresión regular sigue la [sintaxis de la biblioteca de expresiones regulares Boost](http://www.boost.org/doc/libs/release/libs/regex/). Es una [variación de la sintaxis de expresiones regulares de Perl](https://www.boost.org/doc/libs/1_59_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html).

Los caracteres Unicode, incluidos símbolos como emoji, deben coincidirse utilizando sus caracteres literales y no utilizando secuencias de escape Unicode. Por ejemplo, el rango `"[😀-🤯]"` (U+1F600 a U+1F92F) captura con éxito el símbolo 🤔 (U+1F914) en el medio.

La cadena de formato sigue la [Sintaxis de Cadena de Formato Extendida de Boost](http://www.boost.org/doc/libs/1_66_0/libs/regex/doc/html/boost_regex/format/boost_format_syntax.html). Si la cadena de formato es una cadena vacía (`""`), entonces una coincidencia no produce ningún resultado para esa subcadena.

Véase también la función `RegExMatch`.

### Ejemplos {: #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 "Nota"
    `"\"` (barra invertida) debe ser escapada en cadenas literales ya que es el carácter de escape. Para usar un `"\"`, utiliza una barra invertida doble: `"\\"`.

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

Replace(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se buscará y cuyos subcadenas coincidentes serán reemplazadas

-   **`old`:** Una cadena que se usará para la coincidencia

-   **`new`:** Una cadena que se usará como reemplazo para cualquier coincidencia encontrada

### Descripción {: #description }

Busca una cadena para subcadenas que coincidan con el argumento "old" y reemplaza una subcadena coincidente con el argumento "new".

Para operaciones de búsqueda y reemplazo más complejas, consulta la función `RegExReplace`.

### Ejemplos {: #examples }

Replace("Lunes Martes", "día", "noche, día"); // Retorna "Lunes noche, Martes noche,"

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string Right(string str, int n)

### Sintaxis {: #syntax }

Right(, )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

-   **`n`:** El número de caracteres desde el extremo derecho que se devolverán

### Descripción {: #description }

Devuelve `n` caracteres de una cadena, contando desde la derecha (el final) de una cadena.

Consulta también las funciones `Left` y `Mid`.

!!! note "Nota"
    Si la cadena es una cadena numérica que comienza con un cero a la izquierda, debe estar entre comillas o será interpretada como un entero y puede resultar en un índice de carácter inicial diferente.

### Ejemplos {: #examples }

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

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


[[Back to top]](#top)

</div>


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

### Declaración {: #declaration }

string RPad(string s, int n)

### Sintaxis {: #syntax }

string RPad(string s, int n)

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

-   **`n`:** El número de caracteres desde el extremo derecho que se devolverán

### Descripción {: #description }

Agrega espacios a la derecha (el final) de una cadena hasta que la cadena contenga `n` caracteres. Las cadenas que contienen `n` o más caracteres se truncarán a `n` caracteres.

`RPad(str, -n)` es lo mismo que `LPad(str, n)`. Consulta la función `LPad`.

### Ejemplos {: #examples }

RPad("01234567",9); // Devuelve "01234567 "

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

[[Back to top]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

RPadChar(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena
-   **`padChar`:** Una cadena que se utilizará para rellenar caracteres; si hay más de un carácter, se utiliza el primer carácter
-   **`n`:** El número de caracteres desde el extremo derecho que se devolverán

### Descripción {: #description }

Agrega un carácter de relleno a la derecha (el final) de una cadena hasta que la cadena contenga `n` caracteres. Las cadenas que contienen `n` o más caracteres se truncarán a `n` caracteres.

`RPadChar(str, " ", n)` es lo mismo que `RPad(str, n)`. Consulta la función `RPad`.

### Ejemplos {: #examples }

RPadChar(1234567, "0", 10); // Devuelve "1234567000"

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

[[Back to top]](#top)

</div>


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

### Declaración {: #declaration }

string RTrim(string str)

### Sintaxis {: #syntax }

RTrim()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

### Descripción {: #description }
Elimina los espacios en blanco (espacios, tabulaciones) del lado derecho (el final) de una cadena y devuelve los caracteres restantes.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string RTrimChars(string str, string trimChars)

### Sintaxis {: #syntax }

RTrimChars(, )

#### Parámetros requeridos {: #required-parameters }
-   **`str`:** Una cadena que se va a recortar desde la derecha (el final)
-   **`trimChars`:** Una cadena de caracteres de recorte que se deben coincidir; el orden no importa

### Descripción {: #description }
Elimina cualquier carácter final en una cadena desde el final que coincida con los caracteres de recorte y devuelve los caracteres restantes.

Esta función prueba cada carácter final de una cadena, comenzando en el borde derecho, y verifica si se encuentra en los caracteres de recorte. Si lo está, se elimina y el proceso se repite hasta que ya no haya coincidencias.

Esto se puede usar para recortar caracteres distintos de los caracteres de espacio en blanco predeterminados, como recortar dos puntos finales.

Véase también las funciones `LTrimChars` y `TrimChars`.

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

array Split(string str, string delimiter)

### Sintaxis {: #syntax }

Split(, )

#### Parámetros requeridos {: #required-parameters }
-   **`str`:** Una cadena que se va a dividir
-   **`delimiter`:** Una cadena que se debe coincidir como el separador entre cada elemento del arreglo

### Descripción {: #description }
Divide una cadena utilizando una cadena delimitadora, devolviendo el resultado como un arreglo.

Devuelve el resultado en un arreglo de tamaño igual al número de delimitadores más uno. Si la expresión termina con el delimitador, el tamaño del arreglo es igual al número de delimitadores (el último valor vacío se ignora). Si la cadena no contiene delimitadores, se devuelve un arreglo de tamaño uno que contiene la cadena original.

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

Este ejemplo convierte una dirección IP (`"10.6.10.1"`) en un solo entero (`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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

Split([, , ])

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena que se va a dividir

#### Parámetros opcionales {: #optional-parameters }

-   **`delimiter`:** Una cadena que se va a coincidir como el separador entre cada elemento del arreglo
-   **`qualifier`:** Una cadena que se va a coincidir como el separador entre cada elemento del arreglo

### Descripción {: #description }

Divide una cadena con formato CSV y devuelve un arreglo con los valores individuales de las columnas.

Por defecto, el delimitador es una coma (,) y el calificador de cadena es una comilla doble ("). Esto se puede cambiar especificando los segundos y terceros argumentos opcionales respectivamente.

!!! note "Nota"
    Los parámetros opcionales (delimitador y calificador) se pueden especificar con un entero correspondiente al código ASCII del carácter delimitador o calificador.

### Ejemplos {: #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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

int StringLength(string str)

array StringLength(array arr)

### Sintaxis {: #syntax }

StringLength(string str)

StringLength(array arr)

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** (Primera forma) Una cadena

-   **`arr`:** (Segunda forma) Un arreglo

### Descripción {: #description }

Si el argumento es una cadena, la función devuelve la longitud de la cadena.

Si el argumento es un arreglo, la función devuelve un arreglo con cada elemento establecido en la longitud del elemento correspondiente en el arreglo de argumentos. La función `Length` devuelve la longitud de un arreglo en lugar de la longitud de los elementos individuales.

!!! note "Nota"
    Al usar agentes de la versión 12.7 y posteriores, la función admite caracteres UTF-8. Establezca [`jitterbit.script.string.utf8size`](/es/integration-studio/design/variables/jitterbit/scripting-jitterbit-variables/#jitterbitscriptstringutf8size) en `false` en la parte superior para usar el conteo de bytes en su lugar. El conteo de bytes se utiliza por defecto con agentes de la versión 12.6 y anteriores.

### Ejemplos {: #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">

[[Back to top]](#top)

</div>




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

### Declaración {: #declaration }

string ToLower(string str)

### Sintaxis {: #syntax }

ToLower()

#### Parámetros requeridos {: #required-parameters }
-   **`str`:** Una cadena

### Descripción {: #description }
Convierte todas las letras mayúsculas en una cadena a minúsculas.

!!! important "Importante"
    El soporte para caracteres multibyte requiere la versión del agente 12.7 o posterior.

### Ejemplos {: #examples }

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

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

[[Back to top]](#top)

</div>


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

### Declaración {: #declaration }

string ToProper(string str)

### Sintaxis {: #syntax }

ToProper()

#### Parámetros requeridos {: #required-parameters }
-   **`str`:** Una cadena

### Descripción {: #description }
Convierte una cadena a formato de título (la primera letra de cada palabra en mayúscula). Esto es distinto del formato de título, que solo capitaliza palabras seleccionadas y más largas en una cadena.

!!! important "Importante"
    El soporte para caracteres multibyte requiere la versión del agente 12.7 o posterior.

!!! warning "Advertencia"
    La función `ToProper` es tal que nombres como `"mccartney"` que comienzan con `"mc"` solo se convierten correctamente a `"McCartney"` si la palabra está precedida por un carácter de espacio. Para tener una cadena que comience con `"mc"` como `"mccartney, paul"` convertida correctamente a `"McCartney, Paul"`, use un código como este para agregar un espacio precedente y luego eliminarlo inmediatamente:

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

### Ejemplos {: #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">

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string ToUpper(string )

### Sintaxis {: #syntax }

ToUpper()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

### Descripción {: #description }

Convierte todas las letras minúsculas en una cadena a mayúsculas.

!!! important "Importante"
    El soporte para caracteres multibyte requiere la versión 12.7 del agente o posterior.

### Ejemplos {: #examples }

ToUpper("¡Hola Mundo!"); // Devuelve "¡HOLA MUNDO!"

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string Trim(string str)

### Sintaxis {: #syntax }

Trim()

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena

### Descripción {: #description }

Elimina los espacios en blanco del principio y el final de una cadena y devuelve los caracteres restantes.

### Ejemplos {: #examples }

Trim(" ¡Hola Mundo! "); // Devuelve "Hola Mundo!"

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

[[Volver al inicio]](#top)

</div>


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

### Declaración {: #declaration }

string TrimChars(string str, string trimChars)

### Sintaxis {: #syntax }

TrimChars(, )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena a recortar
-   **`trimChars`:** Una cadena de caracteres de recorte a coincidir; el orden no importa

### Descripción {: #description }

Elimina cualquier carácter al principio o al final de una cadena que coincida con los caracteres de recorte y devuelve los caracteres restantes.

Esta función prueba cada carácter inicial y final de una cadena y verifica si se encuentra en los caracteres de recorte. Si es así, se elimina y el proceso se repite hasta que ya no haya coincidencias.

Esto se puede usar para recortar caracteres que no sean los caracteres de espacio en blanco predeterminados, como recortar dos puntos.

Véase también las funciones `LTrimChars` y `RTrimChars`.

### Ejemplos {: #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">

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

Truncate(, , )

#### Parámetros requeridos {: #required-parameters }

-   **`str`:** Una cadena
-   **`firstChars`:** El número de caracteres a eliminar desde la izquierda (el inicio) de la cadena
-   **`lastChars`:** El número de caracteres a eliminar desde la derecha (el final) de la cadena

### Descripción {: #description }

Elimina `firstChar` caracteres desde la izquierda (el inicio) y `lastChars` caracteres desde la derecha (el final) de una cadena y devuelve la cadena restante.

Véase también las funciones `Left` y `Right`.

### Ejemplos {: #examples }

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

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

[[Volver arriba]](#top)

</div>


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

### Declaración {: #declaration }

string URLDecode(string url, string paramName)

### Sintaxis {: #syntax }

URLDecode(, )

#### Parámetros requeridos {: #required-parameters }

-   **`url`:** Una cadena que contiene una URL
-   **`paramName`:** El nombre de un parámetro en la URL cuyo valor se debe devolver

### Descripción {: #description }

Analiza una cadena de URL y devuelve el valor decodificado del parámetro de URL con el nombre especificado. Se ignora el caso del nombre. Si el nombre no se encuentra en los parámetros de la URL, se devuelve una cadena vacía (`""`).

Ve también las funciones `ParseURL` y `URLEncode`.

### Ejemplos {: #examples }

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

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

[[Volver al inicio]](#top)

</div>




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

### Declaración {: #declaration }

string URLEncode(string str[, int encodingOption])

### Sintaxis {: #syntax }

URLEncode([, ])

#### Parámetros requeridos {: #required-parameters }

-   **`url`:** Una cadena que contiene un valor a codificar siguiendo las reglas de [RFC 1738](https://tools.ietf.org/html/rfc1738). También se admiten caracteres multibyte.

#### Parámetros opcionales {: #optional-parameters }

-   **`encodingOption`:** Un entero (0 - 3) que especifica la codificación a utilizar. El valor predeterminado es 0. Consulta la lista a continuación.

### Descripción {: #description }

Codifica una cadena siguiendo [RFC 1738](https://tools.ietf.org/html/rfc1738).

Los valores válidos para la opción de codificación opcional son:

-   `0`: Codificación estándar de URL. Codifica caracteres de control ASCII, caracteres no ASCII, caracteres multibyte, caracteres "reservados" y caracteres "no seguros". Esta es la codificación predeterminada si se omite la opción.
-   `1`: No codificar caracteres "no seguros": " \< \> \# % { } \| \\ ^ \~ \[ \] \` y el carácter de espacio
-   `2`: No codificar caracteres "reservados": ; / ? : @ & =
-   `3`: No codificar caracteres "no seguros" y caracteres "reservados"

Estos caracteres se consideran "seguros" y nunca se codifican: $ - \_ . + ! \* ' ( ) ,

Ve también las funciones `ParseURL` y `URLDecode`.

!!! important "Importante"
    El soporte para caracteres multibyte requiere la versión 12.4 o posterior del agente.

    Si necesitas codificar caracteres "seguros" o caracteres que producen resultados de codificación inesperados, utiliza las funciones de JavaScript `encodeURI` o `encodeURIComponent`:

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

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

### Ejemplos {: #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 ```

[Volver al inicio]