Todas as coleções
Build
Funções Double Braces
Double Braces - Funções de String
Double Braces - Funções de String

Saiba quais são as funções de string associadas aos Double Braces e como utilizá-las.

Micaella Mazoni avatar
Escrito por Micaella Mazoni
Atualizado há mais de uma semana

IMPORTANTE: esta documentação foi descontinuada. Leia a documentação Funções de String atualizada no nosso novo portal de documentação.

As funções foram criadas para:

  • acelerar ainda mais a criação das suas integrações

  • diminuir a complexidade dos seus pipelines

  • simplificar conversões e transformações dos dados durante o fluxo dos seus pipelines

As funções de string realizam tratamentos, operações e conversões de string e estão disponíveis para componentes que suportam expressões com Double Braces. Para saber como passar informações para os componentes utilizando esse recurso, clique aqui.

CAPITALIZE

Essa função em Double Braces capitaliza uma string ao alterar o primeiro caractere para letra maiúscula. Os outros caracteres não são alterados.

Sintaxe

CAPITALIZE(value:string)

Digamos que você precise capitalizar uma string. Você pode fazer o seguinte:

{
 "name": {{ CAPITALIZE("hi, my name is jacob") }}
}

O resultado esperado será:

{
 "name": "Hi, my name is jacob"
}

CONCAT

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função é aplicada para concatenar parâmetros e transformá-los em uma string.

Sintaxe

CONCAT(, , )

Regras

  • ao menos 2 parâmetros são necessários

  • concatenar null é o mesmo que concatenar "" (string vazia)

  • concatenação sempre retorna string

  • o campoX pode ser de qualquer tipo de dados, que será convertido para string na concatenação

Veja um exemplo simples aplicado abaixo:

Entrada de um componente Transformer

{
 "nome": "teste",
 "id": " - 123",
 "a": null,
 "b": {
    "nome": "qwert",
    "id": "yuiop"
 },
 "c": -89912
}

Utilização da função CONCAT:

{
  "concat": {{ CONCAT(message.nome, message.id, message.a, message.b, message.c) }}
}

ESCAPE

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função é aplicada para manter os caracteres que necessitam de um escape mesmo após a conversão para outro elemento. Ela deverá ser utilizada, por exemplo, quando é desejável persistir um objeto JSON que está em formato de string em um banco de dados.

Sintaxe

ESCAPE(valor:string, escapeType:string<optional>)

Veja a seguir um exemplo simples:

{
  "jsonString": "{\"a\": 1,\"b\": 2}"
}

A função pode ser aplicada para um escape:

{
    "texto": {{ ESCAPE(message.jsonString) }}
}

Além disso, é possível especificar o tipo de escape que deve ser aplicado através do parâmetro opcional escapeType. Nele são aceitos os valores "CSV", "HTML", "JSON" e "XML". Caso o parâmetro não seja informado, será assumido o valor "JSON" por padrão.

Digamos que você possua o objeto abaixo e precise aplicar o escape para um texto no formato CSV:

{
    "text": "John,33,\"São Paulo\",Brazil,true"
}

Para isso, basta fazer a chamada da função conforme abaixo:

{
    "text": {{ ESCAPE(message.text, "CSV") }}
}

O resultado da execução da função será o seguinte:

{
    "text": "\"John,33,\"\"São Paulo\"\",Brazil,true\""
}

Para os demais tipos, a aplicação da função é a mesma dependendo apenas do tipo de texto que deverá ser tratado. Caso seja informado algum tipo de escape não esperado pela função, será lançada uma exceção.

UNESCAPE

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função é aplicada para remover os escapes contidos nos caracteres de um texto. Ela deverá ser utilizada, por exemplo, quando é desejável fazer a leitura de um objeto JSON que está em formato de string persistido em um banco de dados.

Sintaxe

UNESCAPE(valor:string, escapeType:string<optional>)

Veja a seguir um exemplo simples:

{
  "jsonString": "{\\\"a\\\": 1,\\\"b\\\": 2}"
}

A função pode ser aplicada para um ESCAPE:

{
    "texto": {{ UNESCAPE(message.jsonString) }}
}

Além disso, é possível especificar o tipo de escape que deve ser removido através do parâmetro opcional escapeType. Nele são aceitos os valores "CSV", "HTML", "JSON" e "XML". Caso o parâmetro não seja informado, será assumido o valor "JSON" por padrão.

Digamos que você possua o objeto abaixo e precise remover o escape de um texto no formato CSV:

{
    "text": "\"John,33,\"\"São Paulo\"\",Brazil,true\""
}

Para isso, basta fazer a chamada da função conforme abaixo:

{
    "text": {{ UNESCAPE(message.text, "CSV") }}
}

O resultado da execução da função será o seguinte:

{
    "text": "John,33,\"São Paulo\",Brazil,true"
}

Para os demais tipos, a aplicação da função é a mesma dependendo apenas do tipo de texto que deverá ser tratado. Caso seja informado algum tipo de escape não esperado pela função, será lançada uma exceção.

INDEXOF

Essa função em Double Braces retorna o índice dentro da primeira ocorrência de uma string referente a uma substring especificada.

Sintaxe

INDEXOF(str: string, strSearch: string, fromIndex:integer<optional>)

Digamos que você precise buscar o valor "planet" dentro da string "Hello planet earth, you are a great planet." e queira saber qual é o índice de início dessa ocorrência:

{{ INDEXOF("Hello planet earth, you are a great planet.", "planet") }}

O resultado será: 6

Caso você precise buscar em uma string a partir de determinado índice:

{{ INDEXOF("Hello planet earth, you are a great planet.", "tree", 3) }}

No caso acima, você está buscando a partir do índice 3. Como não será encontrado nenhum valor com as especificações passadas, então será retornado -1.

JOIN

Essa função em Double Braces retorna uma nova string composta por cópias dos elementos unidos com uma cópia do delimitador especificado.

Sintaxe

JOIN(delimiter:string, value1:string, value2:string, ...., valueN:string)

  • delimiter: delimitador a ser incorporado por cada string

  • values: string a ser unido

Digamos que você precise unir algumas strings com um delimitador. Você pode fazer o seguinte:

{
 "test": {{ JOIN("-", "I", "love", "this", "function") }}
}

O resultado esperado será: 

{
 "test": "I-love-this-function"
}

LASTINDEXOF

Essa função em Double Braces permite localizar a última ocorrência de uma sequência de caracteres em uma string. A função retorna o número de índice em que se inicia a sequência, realiza a busca de caracteres do final para o início da string e retorna -1 se o caractere não é encontrado. A última ocorrência da string vazia ("") é considerada um valor do índice.

Sintaxe

LASTINDEXOF(str: string, strSearch: string, fromIndex:integer<optional>)

Digamos que você queira buscar o valor "planet" dentro da string "Hello planet earth, you are a great planet." e queira saber qual é o índice de início dessa ocorrência:

{{ LASTINDEXOF("Hello planet earth, you are a great planet.", "planet") }}

O resultado será: 36

LEFTPAD

Essa função em Double Braces adiciona preenchimentos à esquerda de uma string com uma string especificada.

Sintaxe

LEFTPAD(value:string, size:number, [padding:string - optional])

  • value: string a ser preenchida

  • size: tamanho total do preenchimento / da string a ser preenchida

  • padding: caractere do preenchimento (opcional)

Digamos que você precise adicionar um preenchimento à esquerda de uma string. Você pode fazer o seguinte: 

{
 "test": {{ LEFTPAD("xpto", 10, "-") }}
}

O resultado esperado será:

{
 "test": "------xpto"
}

IMPORTANTE: se você não especificar o parâmetro "padding", então o preenchimento será feito com um espaço em branco.

LOWERCASE

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função é aplicada para retornar o valor da string em letras minúsculas.

Sintaxe

LOWERCASE(string)

{
 “a”: "2AAA"
}
{
  "lc": {{ LOWERCASE( message.a )  }}
}

O retorno dessa função será 2aaa.

MATCHES

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função procura por toda a string, ou seja, o padrão (regex) que você está procurando deve ser exatamente igual à string sendo usada para a procura.

Sintaxe

MATCHES(string, regex )

Vamos supor que você precisa saber se o campo está no formato de "cep" válido:

{
 "cep": "01200-030"
}

No exemplo abaixo o valor "true" será atribuído, pois bate com a regex passada:

{
  "cepValido": {{ MATCHES( message.cep, "[0-9]{5}-[0-9]{3}" )  }}
}

O retorno dessa função será "true" ou "false".

NORMALIZE

Essa função em Double Braces normaliza uma sequência de valores em caracteres.

Sintaxe

NORMALIZE(value:string)

  • value: string a ser normalizada

Digamos que você precise normalizar uma string. Você pode fazer o seguinte:

{
 "test": {{ NORMALIZE("àèìòùęëæoœçáíéúūãõ") }}
}

O resultado esperado será: 

{
 "test": "aeioueeocaieuuao"
}

REPLACE

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função substitui cada substring da string que corresponde à expressão regular fornecida com a substituição que se deseja realizar.

Sintaxe

REPLACE(valor, "regExp", "valor-novo")

  • regExp: expressão regular a ser informada como string

O resultado será uma string ou null.

Veja a seguir um exemplo simples:

{
  "string": "ABCDabcd", 
  "object": {
    "this is an object": true
  }, 
  "text": "this is a test" ,
  "acentos": "ÁÂÃáâãÉéíÌÍÓóÛÙúÇç"
}

Exemplo de aplicação:

{
  "replace_simple": {{REPLACE(message.string, "[A-Z]", ".")}}, 
  "replace_object": {{REPLACE(message.object, "\\\"", "'")}}, 
  "replace_text": {{REPLACE(message.text, "a test", "my test")}},
  "acentos": {{ REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(message.XML,"[\\xE0-\\xE6]", "a"),"[\\xC0-\\xC6]", "A"),"[\\xE8-\\xEB]", "e"),"[\\xC8-\\xCB]", "E"),"[\\xEC-\\xEF]", "i"),"[\\xCC-\\xCF]", "I"),"[\\xF2-\\xF6]", "o"),"[\\xD2-\\xD6]", "O"),"[\\xF9-\\xFC]", "u"),"[\\xD9-\\xDC]", "U"),"\\xE7", "c"),"\\xC7", "C") }}
}
}

RIGHTPAD

Essa função em Double Braces adiciona preenchimentos à direita de uma string com uma string especificada.

Sintaxe

RIGHTPAD(value:string, size:number, [padding:string - optional])

  • value: string a ser preenchida

  • size: tamanho do preenchimento

  • padding: caractere do preenchimento (opcional)

Digamos que você precise adicionar um preenchimento à direita de uma string. Você pode fazer o seguinte: 

{
 "test": {{ RIGHTPAD("xpto", 10, "-") }}
}

O resultado esperado será:

{
 "test": "xpto------"
}

Se você não especificar o parâmetro "padding", então o preenchimento será feito com um espaço em branco.

SPLIT

Essa função em Double Braces divide uma string de acordo com a expressão regular especificada (regex).

Sintaxe

SPLIT(value:string, regex:string)

  • value: string a ser normalizada

  • regex: expressão regular delimitadora

Digamos que você precise dividir uma string com um regex. Você pode fazer o seguinte:

{
 "test": {{ SPLIT("aaa,bbb", ",") }},
 "test2": {{ SPLIT("123,abb", "\\.") }}
}

O resultado esperado será:

{
 "test": ["aaa", "bbb"],
 "test2": ["123", "abb"]
}

SUBSTRING

Essa função em Double Braces retorna uma string derivada da sua própria substring. A substring começa no "beginIndex" especificado e se estende até o caractere no índice "endIndex".

Sintaxe

SUBSTRING(value:string, beginIndex:number, [endIndex:number - optional], throwIndexOutOfBoundError:boolean - optional])

  • value: string

  • beginIndex: índice inicial, inclusivo

  • beginIndex: índice final, exclusivo (opcional)

  • throwIndexOutOfBoundError: se "true", uma exceção será lançada caso exista algum índice fora da exceção vinculada; do contrário, a string passada será retornada - "true" é padrão (se "beginIndex" for negativo, ou "endIndex" for maior do que o tamanho do objeto da string, ou "beginIndex" for maior que "endIndex", uma exceção será lançada)

Digamos que você precise extrair uma substring de uma string. Você pode fazer o seguinte:

{
 "test": {{ SUBSTRING("aaS2fdeS", 3) }},
 "test2": {{ SUBSTRING("aaS2fdeS", 3, 5) }},
 "test3": {{ SUBSTRING("qqq", 20, 30, false) }}
}

O resultado esperado será:

{
 "test": "2fdeS",
 "test2": "2f",
 "test3": "qqq"
}

Para esses casos, uma exceção será lançada:

{{ SUBSTRING("qqq", 20, 30) }} or {{ SUBSTRING("qqq", 20, 30, true) }}

ou

{{ SUBSTRING("qqq", 20, null, false) }}

TOSTRING

Essa função em Double Braces converte qualquer coisa para um formato string.

Sintaxe

TOSTRING(value:any)

  • value: valor a ser convertido para string

Digamos que você precise passar um valor para string. Você pode fazer o seguinte:

{
 "number": {{ TOSTRING(1) }},
 "string": {{ TOSTRING("A") }},
 "boolean": {{ TOSTRING(false) }},
 "null": {{ TOSTRING(null) }}
}

O resultado esperado será:

{
 "number": "1",
 "number": "A",
 "number": "false",
 "number": ""
}

Também é possível passar um array ou um objeto para string.

UPPERCASE

Utilizando Double Braces, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.

A função é aplicada para retornar o valor da string em letras maiúsculas.

Sintaxe

UPPERCASE(string)

{
 “a”: "2aaa"
}
{
  "uc": {{ UPPERCASE( message.a )  }}
}

O retorno dessa função será 2AAA.

CONTAINS

Essa função permite que você verifique se um determinado valor está contido em uma string.

Sintaxe:

CONTAINS(string, value)

Digamos que você precise verificar se a string abaixo contém o valor "function":

{
  "field": "Testing the new function CONTAINS()"
}

Verificando:

{
  "contains": {{ CONTAINS(message.field, "function") }}
}

O resultado será:

{
  "contains": true
}

RANDOMSTRINGS

Essa função permite que você gere strings randômicas com base em um charset e um tamanho.

Sintaxe:

RANDOMSTRINGS(charset, size)

Digamos que você precise gerar strings randômicas com base em diferentes charsets e com tamanhos de 20 caracteres.

Gerando as strings:

{
    "alphanumeric": {{ RANDOMSTRINGS("ALPHANUMERIC", 20) }},
    "ascii": {{ RANDOMSTRINGS("ASCII", 20) }},
    "numeric": {{ RANDOMSTRINGS("NUMERIC", 20) }},
    "alphabetic": {{ RANDOMSTRINGS("ALPHABETIC", 20) }}
}

O resultado será:

{
  "alphanumeric": "Oj3DApYQL7uTCodbXlXq",
  "ascii": "GV>o8G/pNFofal.A.14X",
  "numeric": "02747673464573026135",
  "alphabetic": "bOHtZafvGOpdltVrrcEu"
}

Os charsets aceitos são ALPHANUMERIC, ASCII, NUMERIC e ALPHABETIC, e o tamanho limite da string é de 1000 caracteres.

STRINGMATCHES

Essa função permite realizar buscas de valores dentro de uma String com base em uma Regex, retornando os resultados encontrados dentro de um array.

Sintaxe:

STRINGMATCHES(value: string, regex: string, flagPattern: string)

  • value: string a ser preenchida

  • regex: será utilizado na busca

  • patternFlag: flag que pode definir um padrão para o match da regex (opcional)

Obs: a função aceita mais de uma patternFlag, caso desejar poderá passar todas que quiserem nos últimos parametros da função, como exemplo abaixo:

STRINGMATCHES(Hello eDUcatIVE, educative # Matching the keyword educative, “CASE_INSENSITIVE”, “COMMENTS”)

Obs: Segue abaixo a tabela das patternFlags válidas:

CANON_EQ

Habilita a equivalência canônica.

CASE_INSENSITIVE

Ativa a correspondência que não diferencia maiúsculas de minúsculas.

COMMENTS

Permite espaços em branco e comentários no padrão.

DOTALL

Ativa o modo de pontos.

LITERAL

Habilita a análise literal do padrão.

MULTILINE

Ativa o modo multilinha.

UNICODE_CASE

Ativa a dobra de maiúsculas e minúsculas com reconhecimento unicode.

UNICODE_CHARACTER_CLASS

Habilita a versão ‘unicode’ de classes de caracteres predefinidas e classes de caracteres posix.

UNIX_LINES

Habilita o modo de linhas Unix.

Digamos que você queira fazer as buscas abaixo.

Gerando as ‘strings’:

{
"normal": {{ STRINGMATCHES("7801111111blahblah  780222222 mumbojumbo7803333333 thisnthat 7804444444", "780{1}\\d{7}") }},
"case_sensitive": {{ STRINGMATCHES("Para maiores informações, veja o Capítulo 3.4.5.1", "(capítulo \d+(\.\d)*)") }},
"case_insensitive": {{ STRINGMATCHES("Para maiores informações, veja o Capítulo 3.4.5.1", "(capítulo \d+(\.\d)*)", "CASE_INSENSITIVE") }}
}

O resultado será:

{
"normal": [ "7801111111",  "7803333333",  "7804444444" ],
"case_sensitive": [],
"case_insensitive": ["Capítulo 3.4.5.1"] 
}

Obs: Caso a regex a ser utilizada tenha barra invertida (\), é necessário um scape adicionando outra barra invertida. Segue abaixo exemplo:

Regex original: 

(capítulo \d+(\.\d)*)

Regex com scape: 

(capítulo \\d+(\\.\\d)*)

Conheça também as funções:

Artigos relacionados
Double Braces - Funções
Double Braces - Funções Condicionais
Double Braces - Funções Numéricas
Double Braces - Funções de Utilidades
Double Braces - Funções Matemáticas
Respondeu à sua pergunta?