Funções de texto

A lista mostra as funções de texto que você pode usar em expressões.


Função	Descrição
`~=`	Pode ser parte de uma instrução `If` ou `Case`. Retorna `true` se a string de expressão regular do `Arg2` corresponde à string do `Arg1`. Exemplos: `If( "aab" ~= "a+" , "true", "false" )` `Case when "aba" ~= ".a+$" then "true" else "false" end`
`Concatenate(Arg1, ...)`	Concatena (anexa) todos os argumentos em uma string. Se um argumentos é dado, então o resultado é a concatenação de todas as linhas. Se mais de um argumento é dado, então cada linha é concatenada. Os argumentos podem ser de qualquer tipo, mas são convertidos em strings. O resultado é do tipo string. Argumentos nulos são ignorados. Exemplos: `Concatenate("April ", 20+1, "st")` → `"April 21st"` `Concatenate(null, "Ape")`→ `"Ape"` `Concatenate (null, null)` → (Vazio)
`Find(Arg1, Arg2, Arg3)`	Retorna o índice de ocorrência da string `Arg1` em `Arg2`. `Arg3` indica opcionalmente qual correspondência retornar. Se não for fornecido um terceiro argumento, a primeira correspondência será retornada. Se nenhuma correspondência for encontrada, será retornado 0. A pesquisa é sensível a maiúsculas e minúsculas. Os dois primeiros argumentos são do tipo string e o terceiro argumento e o resultado são do tipo inteiro. Se `Arg1` for a string vazia, 0 será retornado. Exemplos: `Find("lo", "Hello")` → 4 `Find("a", "Hello")` → 0 `Find("", "Hello")` → 0 `Find("", null)` → (Vazio) `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)`	Retorna os primeiros caracteres `Arg2` da string `Arg1`. `Arg1` e o resultado são do tipo string. `Arg2` é do tipo real, mas somente a parte inteira é utilizada. Se `Arg2` `>` comprimento do `Arg1`, toda a string é retornada. Se `Arg2` for negativo, o número de caracteres de `Arg2` será removido do lado direito da string `Arg1`. Exemplos: `Left("Daddy", 1)` → `"D"` `Left("Daddy", 3.99)` → `"Dad"` `Left("Daddy", 386)` → `"Daddy"` `Left("Daddy", -1)` → `"Dadd"`
`Len(Arg1)`	Retorna o comprimento de `Arg1`. `Arg1` é do tipo string, e o resultado é do tipo integer. Exemplos: `Len("Hello")` → 5 `Len(null)` → (Vazio)
`Lower(Arg1)`	Retorna `Arg1` convertido em minúsculas. `Arg1` e o resultado são do tipo string.
`Mid(Arg1, Arg2, Arg3)`	Retorna a substring de `Arg1` começando no índice `Arg2` com um comprimento de caracteres de `Arg3`. `Arg1` e o resultado são do tipo string. `Arg2` e `Arg3` são do tipo real, mas somente a parte integer é utilizada. Se `Arg2 > Len(Arg1)`, uma string vazia será retornada. Porém, se `Arg2+Arg3 > Len(Arg1)`, `Arg3` será ajustado para `1+Len(Arg1)-Arg2`. Se `Arg2` ou `Arg3` for negativo ou se `Arg2` for zero, será retornado um erro. Exemplos: `Mid("Daddy", 2, 3)` → `"add"` `Mid("Daddy", 386, 4)` → `""` `Mid("Daddy", 4, 386)` → `"dy"` `Mid("Daddy", -1, 2)` → (Vazio) `Mid("Daddy", 2, -1)` → (Vazio)
`MostCommon(Arg1)`	Retorna o valor mais comum da coluna especificada. Se muitos valores forem igualmente comuns, o primeiro será utilizado. Exemplo: `MostCommon([Column])`
`NameDecode(Arg1)`	Substitui todos os códigos de substring com os caracteres decodificados. Os nomes das colunas no Spotfire são armazenados como strings codificadas de UTF-16. Exemplo: `NameDecode("Column %02D")`
`NameEncode(Arg1)`	Codifica os caracteres na string, de modo que a string contenha apenas caracteres correspondentes à expressão regular `[.0-9a-zA-Z]`. Os nomes das colunas no Spotfire são armazenados como strings codificadas de UTF-16. Exemplo: `NameEncode("Column £")`
`Repeat`	Repete uma string um determinado número de vezes. Exemplo: `Repeat("Hello", 2)` → `"HelloHello"`
`Right(Arg1, Arg2)`	Retorna os últimos caracteres `Arg2` da string `Arg1`. `Arg1` e o resultado são do tipo string. `Arg2` é do tipo real, mas somente a parte inteira é utilizada. Se `Arg2 >` comprimento do `Arg1`, toda a string é retornada. Se `Arg2` for negativo, o número de caracteres de `Arg2` será removido do lado esquerdo da string `Arg1`. Exemplos: `Right("Daddy", 1)` → `"y"` `Right("Daddy", 3.99)` → `"ddy"` `Right("Daddy", 386)` → `"Daddy"` `Right("Daddy", -1)` → `"addy"`
`RXExtract(Arg1, Arg2, Arg3)`	Retorna a parte de uma string (`Arg1`) que correspondem a uma expressão regular (`Arg2`).. `Arg3` determina qual correspondência deve ser usada quando existem várias correspondências. Exemplos: `RXExtract([Column], "l+", 1)` `RXExtract("Parallel", "l+", 1)` → `"ll"` `RXExtract("Parallel", "l+", 2)` → `"l"`
`RXReplace(Arg1, Arg2, Arg3, Arg4)`	Substitui uma substring de acordo com uma expressão regular. Pesquise a expressão regular `Arg2` em `Arg1` e substitua-a por `Arg3`. `Arg4` especifica as opções para a substituição: "g" especifica que, se `Arg2` corresponder mais de uma vez, todas as correspondências deverão ser substituídas. "i" especifica que a comparação não deve diferenciar maiúsculas de minúsculas. "s", para o modo de linha única, especifica que o ponto (.) corresponde a todos os caracteres (em vez de todos os caracteres, exceto nova linha). Alguns caracteres, como o caractere de barra invertida "\" e os parênteses "(" e ")", devem ser precedidos para trabalhar ao usar colunas calculadas. Como os parênteses são usados para o agrupamento em expressões regulares, "(" e ")" deverão ter escape caso o sinal ( ou ) deva ser correspondido. Além disso, quando o caractere é usado em uma expressão regular, as barras invertidas duplas são necessárias para escapar a string do Spotfire e a expressão regular. Veja a literatura sobre elementos de linguagem de expressão regular, por exemplo, no MSDN, para mais informações. Exemplos: `RXReplace("Hello", "L+", "LL", "i")` → `"HeLLo"` `RXReplace("3 Minor", "(\\d).*", "$1", "")` → 3 `RXReplace([Coluna com valores entre parênteses], "\$89\$", "", "")` `RXReplace("change\\slashdirection","\\\\","/","")` → `change/slashdirection` (No último exemplo, a barra invertida precisa ser precedida duas vezes; uma para a string do Spotfire e uma vez para a expressão regular.)
`Split(Arg1, Arg2, Arg3)`	Divide os valores em `Arg1` em várias substrings, usando `Arg2` como separador. `Arg3` especifica qual dos valores deve ser retornado como uma nova coluna. Somente uma coluna é retornada. Utilize um `Arg3` negativo para especificar que a divisão deve ser feita do fim da string em direção ao começo, e não o contrário. Por exemplo, se uma coluna denominada "X" com o valor "`a.b`" for dividida em duas partes utilizando o separador "`.`", `Split([X],".",1)` retornará "`a`" e `Split([X],".",2)` retornará "`b`". Exemplos: `Split([Column]," ",2)` `Split([Column]," ",-2)` `Split([Column]," / ",3)`
`Substitute(Arg1, Arg2, Arg3)`	Substitui todas as ocorrências de `Arg2` em `Arg1` por `Arg3`. A pesquisa é sensível a maiúsculas. Exemplo: `Substitute("Test","t","ting")` → `"Testing"`
`Substring(Arg1, Arg2, Arg3)`	Retorna a substring de `Arg1` começando no índice `Arg2` com um comprimento de caracteres de `Arg3`. `Arg1` e o resultado são do tipo string. `Arg2` e `Arg3` são do tipo real, mas somente a parte integer é utilizada. Se `Arg2 > Len(Arg1)`, uma string vazia será retornada. Porém, se `Arg2+Arg3 > Len(Arg1)`, `Arg3` será ajustado para `1+Len(Arg1)-Arg2`. Se `Arg2` ou `Arg3` for negativo ou se `Arg2` for zero, será retornado um erro. Exemplos: `Substring("Daddy", 2, 3)` → `"add"` `Substring("Daddy", 386, 4)` → `""` `Substring("Daddy", 4, 386)` → `"dy"` `Substring("Daddy", -1, 2)` → (Empty) `Substring("Daddy", 2, -1)` → (Vazio)
`Trim(Arg1)`	Remove caracteres com espaço em branco desde o início até o fim de uma string. Exemplo: `Trim(" Example "`) → `"Example"`
`UniqueConcatenate(Arg1)`	Concatena os valores originais convertidos em strings. Os valores são ordenados de acordo com o comparador. Exemplo: `UniqueConcatenate([Column])`
`Upper(Arg1)`	Retorna `Arg1` convertido em maiúsculas. `Arg1` e o resultado são do tipo string. Exemplo: `Upper("hello")` → `"HELLO"`

Veja tambémFunções.