Funciones de texto

La lista enumera las funciones de texto que puede utilizar en expresiones.


Función	Descripción
`~=`	Puede ser parte de una declaración `If` o `Case`. Devuelve el valor `true` si la cadena de expresiones regulares `Arg2` coincide con la cadena `Arg1`. Ejemplos: `If( "aab" ~= "a+" , "true", "false" )` `Case when "aba" ~= ".a+$" then "true" else "false" end`
`Concatenate(Arg1, ...)`	Concatena (anexa) todos los argumentos en una cadena. Si se da un argumento, el resultado es la concatenación de todas las filas. Si se da más de un argumento, se concatena cada fila. Los argumentos pueden ser de cualquier tipo, pero se convierten en cadenas. El resultado es una cadena. Se ignorarán los argumentos nulos. Ejemplos: `Concatenate("April ", 20+1, "st")` → `"April 21st"` `Concatenate(null, "Ape")`→ `"Ape"` `Concatenate (null, null)` → (Empty)
`Find(Arg1, Arg2, Arg3)`	Devuelve el índice de la aparición de la cadena `Arg1` en `Arg2`. `Arg3` indica opcionalmente la coincidencia que se debe devolver. Si no se indica un tercer argumento, se devolverá la primera asociación. Si no se encuentra ninguna asociación, se devuelve el valor 0. La búsqueda distingue mayúsculas de minúsculas. Los dos primeros argumentos son del tipo cadena y el tercer argumento y el resultado son del tipo entero. Si `Arg1` es una cadena vacía, se devolverá el valor 0. Ejemplos: `Find("lo", "Hello")` → 4 `Find("a", "Hello")` → 0 `Find("", "Hello")` → 0 `Find("", null)` → (Empty) `If(Find("Pri 1", [Col1])>0, "Important", "Not important")` `Find("a", "ababab")` → 1 `Find("a", "ababab", 2)` → 3 `Find("a", "ababab", 10)` → 0
`Left(Arg1, Arg2)`	Devuelve los primeros `Arg2` `caracteres de la cadena Arg1`. `Arg1` y el resultado es de tipo cadena. `Arg2` es de tipo real, pero solo se usa la parte del número entero. Si `Arg2` `>` la longitud de `Arg1`, se devuelve la cadena completa. Si `Arg2` es negativo, el número de caracteres de `Arg2` se eliminará del lado derecho de la cadena `Arg1`. Ejemplos: `Left("Daddy", 1)` → `"D"` `Left("Daddy", 3.99)` → `"Dad"` `Left("Daddy", 386)` → `"Daddy"` `Left("Daddy", -1)` → `"Dadd"`
`Len(Arg1)`	Devuelve la longitud de `Arg1`. `Arg1` es una cadena, y el resultado, un número entero. Ejemplos: `Len("Hello")` → 5 `Len(null)` → (Empty)
`Lower(Arg1)`	Devuelve `Arg1` convertido a minúscula. `Arg1` y el resultado es de tipo cadena.
`Mid(Arg1, Arg2, Arg3)`	Devuelve la subcadena de `Arg1` que empieza en el índice `Arg2` con una longitud de `Arg3` caracteres. `Arg1` y el resultado es de tipo cadena. `Arg2` y `Arg3` son del tipo real, pero solo se usa la parte del número entero. Si `Arg2 > Len(Arg1)`, se devuelve una cadena vacía. Por otro lado, si `Arg2+Arg3 > Len(Arg1)`, `Arg3` se ajusta a `1+Len(Arg1)-Arg2`. Si `Arg2` o `Arg3` son negativos o si `Arg2` equivale a cero, se devolverá un error. Ejemplos: `Mid("Daddy", 2, 3)` → `"add"` `Mid("Daddy", 386, 4)` → `""` `Mid("Daddy", 4, 386)` → `"dy"` `Mid("Daddy", -1, 2)` → (Empty) `Mid("Daddy", 2, -1)` → (Empty)
`MostCommon(Arg1)`	Devuelve el valor más común de la columna seleccionada. Si hay varios valores con la misma frecuencia, se usará el primero. Ejemplo: `MostCommon([Column])`
`NameDecode(Arg1)`	Sustituye todos los códigos de subcadena por caracteres descodificados. Los nombres de columna en Spotfire se almacenan como cadenas codificadas mediante UTF-16. Ejemplo: `NameDecode("Column %02D")`
`NameEncode(Arg1)`	Codifica los caracteres en la cadena para que solo contenga caracteres que coincidan con la expresión regular `[.0-9a-zA-Z]`. Los nombres de columna en Spotfire se almacenan como cadenas codificadas mediante UTF-16. Ejemplo: `NameEncode("Column £")`
`Repeat`	Repite una cadena un número especificado de veces. Ejemplo: `Repeat("Hello", 2)` → `"HelloHello"`
`Right(Arg1, Arg2)`	Devuelve los últimos `Arg2` caracteres de la cadena `Arg1`. `Arg1` y el resultado es de tipo cadena. `Arg2` es de tipo real, pero solo se usa la parte del número entero. Si `Arg2 >`la longitud de `Arg1`, se devuelve la cadena completa. Si `Arg2` es negativo, el número de caracteres de `Arg2` se eliminará del lado izquierdo de la cadena `Arg1`. Ejemplos: `Right("Daddy", 1)` → `"y"` `Right("Daddy", 3.99)` → `"ddy"` `Right("Daddy", 386)` → `"Daddy"` `Right("Daddy", -1)` → `"addy"`
`RXExtract(Arg1, Arg2, Arg3)`	Devuelve la parte de una cadena (`Arg1`) que coincide con una expresión regular (`Arg2`). `Arg3` determina la asociación que se debe utilizar cuando existen varias asociaciones. Ejemplos: `RXExtract([Column], "l+", 1)` `RXExtract("Parallel", "l+", 1)` → `"ll"` `RXExtract("Parallel", "l+", 2)` → `"l"`
`RXReplace(Arg1, Arg2, Arg3, Arg4)`	Sustituye una subcadena según una expresión regular. Busque la expresión regular `Arg2` en `Arg1` y sustitúyala por `Arg3`. `Arg4` especifica las opciones para la sustitución: "g" especifica que si `Arg2` coincide más de una vez, todas las coincidencias deben sustituirse. "i" especifica que la comparación no debe distinguir entre mayúsculas y minúsculas. "s", para el modo de una sola línea, especifica que el punto (.) coincide con todos los caracteres (en lugar de todos los caracteres excepto la nueva línea). Algunos caracteres, como el de barra inclinada inversa "\" y el paréntesis "(" y ")" necesitan un carácter de escape para que funcionen con las columnas calculadas. Debido a que los paréntesis se usan para agrupar en las expresiones regulares, "(" y ")" necesitan un carácter de escape si los símbolos ( o ) deben coincidir; y cuando el carácter se utiliza en una expresión regular, se deben usar barras inclinadas inversas dobles como caracteres de escape para la cadena de Spotfire y la expresión regular. Consulte la documentación acerca de los elementos del idioma de las expresiones regulares (por ejemplo, en MSDN) a fin de obtener más información. Ejemplos: `RXReplace("Hello", "L+", "LL", "i")` → `"HeLLo"` `RXReplace("3 Minor", "(\\d).*", "$1", "")` → 3 `RXReplace([Column with values within parenteses], "\$89\$", "", "")` `RXReplace("change\\slashdirection","\\\\","/","")` → `change/slashdirection` (En el último ejemplo, la barra invertida debe escaparse dos veces; una para la cadena Spotfire y otra para la expresión regular).
`Split(Arg1, Arg2, Arg3)`	Divide los valores de `Arg1` en varias subcadenas, utilizando `Arg2` como separador. `Arg3` especifica los valores que se deben devolver como una nueva columna. Solo se devuelve una columna. Use un valor negativo de `Arg3` para determinar que la división se debe realizar desde el final de la cadena hasta el principio en lugar de hacerla desde el principio hasta el final. Por ejemplo, si una columna llamada "X" que contiene el valor "`a.b`" se divide en dos partes usando el separador "`.`", `Split([X],".",1)` devolverá "`a`" y `Split([X],".",2)` devolverá "`b`". Ejemplos: `Split([Column]," ",2)` `Split([Column]," ",-2)` `Split([Column]," / ",3)`
`Substitute(Arg1, Arg2, Arg3)`	Sustituye todas las apariciones de `Arg2` en `Arg1` por `Arg3`. La búsqueda distingue mayúsculas de minúsculas. Ejemplo: `Substitute("Test","t","ting")` → `"Testing"`
`Substring(Arg1, Arg2, Arg3)`	Devuelve la subcadena de `Arg1` que empieza en el índice `Arg2` con una longitud de `Arg3` caracteres. `Arg1` y el resultado es de tipo cadena. `Arg2` y `Arg3` son del tipo real, pero solo se usa la parte del número entero. Si `Arg2 > Len(Arg1)`, se devuelve una cadena vacía. Por otro lado, si`Arg2 + Arg3 > Len(Arg1)`, `Arg3` se ajusta a `1+Len(Arg1) - Arg2`. Si `Arg2` o `Arg3` son negativos o si `Arg2` equivale a cero, se devolverá un error. Ejemplos: `Substring("Daddy", 2, 3)` → `"add"` `Substring("Daddy", 386, 4)` → `""` `Substring("Daddy", 4, 386)` → `"dy"` `Substring("Daddy", -1, 2)` → (Empty) `Substring("Daddy", 2, -1)` → (Empty)
`Trim(Arg1)`	Elimina los caracteres de espacio en blanco del principio o del final de una cadena. Ejemplo: `Trim(" Example "`) → `"Example"`
`UniqueConcatenate(Arg1)`	Concatena los valores exclusivos convertidos en cadenas. Los valores se ordenan según el comparador. Ejemplo: `UniqueConcatenate([Column])`
`Upper(Arg1)`	Devuelve `Arg1` convertido a mayúscula. `Arg1` y el resultado es de tipo cadena. Ejemplo: `Upper("hello")` → `"HELLO"`

Consulte también Funciones.