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)

Veja a seguir um exemplo simples:

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

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

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

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
}

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

Encontrou sua resposta?