> For the complete documentation index, see [llms.txt](https://docs.digibee.com/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/double-braces/double-braces-functions/string-functions.md). # Funções de string As funções de string são usadas para manipular dados do tipo string. Estas são as funções de string que você pode usar com a linguagem Double Braces da Digibee: | Função | Descrição | | ------------------ | ------------------------------------------------------------------------------------- | | `CAPITALIZE` | Converte o primeiro caractere de uma string para maiúsculo | | `LOWERCASE` | Converte todos os caracteres para minúsculo | | `UPPERCASE` | Converte todos os caracteres para maiúsculo | | `NORMALIZE` | Transforma caracteres especiais em caracteres não especiais | | `CONTAINS` | Verifica se uma substring está contida em uma string | | `INDEXOF` | Retorna o índice da primeira ocorrência de uma substring | | `LASTINDEXOF` | Retorna o índice da última ocorrência de uma substring | | `MATCHES` | Verifica se uma string corresponde a uma expressão regular | | `STRINGMATCHES` | Retorna todas as expressões correspondentes em uma string que satisfazem um padrão | | `FUZZYMATCH` | Realiza uma comparação aproximada entre uma string e uma lista de candidatos | | `CONCAT` | Concatena qualquer número de strings em uma única string | | `CONCATWITHOUTTAB` | Concatena strings e substitui caracteres de tabulação por espaços | | `JOIN` | Concatena uma lista de strings com um separador especificado | | `REPLACE` | Substitui todas as ocorrências de uma substring com base em uma expressão regular | | `SPLIT` | Divide uma string em um array com base em uma expressão regular | | `SUBSTRING` | Extrai uma substring de uma string | | `TRIM` | Remove espaços em branco no início e no fim de uma string | | `LEFTPAD` | Preenche o lado esquerdo de uma string com um caractere até um comprimento específico | | `RIGHTPAD` | Preenche o lado direito de uma string com um caractere até um comprimento específico | | `ESCAPE` | Codifica uma string usando sequências de escape | | `UNESCAPE` | Decodifica uma string que contém sequências de escape | | `DEFAULT` | Retorna um valor padrão para referências nulas ou inexistentes | | `TOSTRING` | Converte um objeto para sua representação em string | | `RANDOMSTRINGS` | Gera strings aleatórias a partir de um charset e comprimento | ## **Capitalização e normalização** ### **CAPITALIZE** Converte o primeiro caractere de uma string para maiúsculo. Os demais caracteres não são afetados. #### **Sintaxe** ``` CAPITALIZE(value : string) -> string ``` * `value`: a string cujo primeiro caractere será convertido para maiúsculo. **Retorna:** uma string que é uma versão de `value` com o primeiro caractere em maiúsculo. #### **Exemplo de uso** ``` {{ CAPITALIZE("hello, world!") }} ``` O resultado esperado é: ``` "Hello, world!" ``` ### **LOWERCASE** Converte todos os caracteres para minúsculo. #### **Sintaxe** ``` LOWERCASE(value: string) -> string ``` * `value`: a string de entrada a ser convertida para minúsculo. **Retorna:** a string equivalente em minúsculo da string de entrada. #### **Exemplo de uso** ``` {{ LOWERCASE("HELLO, WorLD!") }} ``` O resultado esperado é: ``` "hello, world!" ``` ### **UPPERCASE** Converte todos os caracteres para maiúsculo. #### **Sintaxe** ``` UPPERCASE(value: string) -> string ``` * `value`: a string de entrada a ser convertida para maiúsculo. **Retorna:** a string equivalente em maiúsculo da string de entrada. #### **Exemplo de uso** ``` {{ UPPERCASE("Hello, world!") }} ``` O resultado esperado é: ``` "HELLO, WORLD!" ``` ### **NORMALIZE** Transforma caracteres especiais em caracteres não especiais. #### **Sintaxe** ``` NORMALIZE(value: string) -> string ``` * `value`: a string a ser normalizada. **Retorna:** a string normalizada com os caracteres especiais substituídos pelos seus equivalentes não especiais. #### **Exemplo de uso** ``` {{ NORMALIZE("São Paulo") }} ``` O resultado esperado é: ``` "Sao Paulo" ``` ## **Busca e correspondência** ### **CONTAINS** Verifica se uma substring está contida em uma string. #### **Sintaxe** ``` CONTAINS(main_string: string, sub_string: string) -> boolean ``` * `main_string`: a string principal onde a busca será realizada. * `sub_string`: a substring a ser buscada. **Retorna:** `true` se a substring for encontrada na string principal, `false` caso contrário. #### **Exemplo de uso** ``` {{ CONTAINS("Hello, world!", "world") }} ``` O resultado esperado é: ``` true ``` ### **INDEXOF** Retorna o índice da primeira ocorrência de uma substring em uma string. A busca diferencia maiúsculas de minúsculas e o índice começa em 0. #### **Sintaxe** ``` INDEXOF(main_string: string, sub_string: string, fromIndex: integer) -> int ``` * `main_string`: a string principal onde a busca será realizada. * `sub_string`: a substring a ser buscada. * `fromIndex`: o índice a partir do qual a busca deve começar. O padrão é `0`. **Retorna:** um inteiro indicando o índice da primeira ocorrência da substring na string principal. Se a substring não for encontrada, a função retorna `-1`. #### **Exemplos de uso** **1. Substring encontrada** ``` {{ INDEXOF("Hello, world!", "world") }} ``` O resultado esperado é: ``` 7 ``` **2. Substring não encontrada** ``` {{ INDEXOF("Hello, world!", "welcome") }} ``` O resultado esperado é: ``` -1 ``` ### **LASTINDEXOF** Retorna o índice da última ocorrência de uma substring em uma string. A busca diferencia maiúsculas de minúsculas e o índice começa em 0. #### **Sintaxe** ``` LASTINDEXOF(main_string: string, sub_string: string) -> int ``` * `main_string`: a string principal onde a busca será realizada. * `sub_string`: a substring a ser buscada. * `fromIndex`: o índice a partir do qual a busca deve começar. O padrão é `0`. **Retorna:** um inteiro indicando o índice da última ocorrência da substring na string principal. Se a substring não for encontrada, a função retorna `-1`. #### **Exemplos de uso** **1. Substring encontrada** ``` {{ LASTINDEXOF("Hello, world!", "o") }} ``` O resultado esperado é: ``` 8 ``` **2. Substring não encontrada** ``` {{ LASTINDEXOF("Hello, world!", "a") }} ``` Como a substring `"a"` não está contida na string `"Hello, world!"`, o resultado esperado é: ``` -1 ``` ### **MATCHES** Verifica se uma string corresponde a uma expressão regular. #### **Sintaxe** ``` MATCHES(value: string, pattern: string) -> boolean ``` * `value`: a string a ser verificada contra a expressão regular. * `pattern`: o padrão de expressão regular a ser usado na verificação. **Retorna:** `true` se a string de entrada corresponder à expressão regular, `false` caso contrário. #### **Exemplo de uso** ``` {{ MATCHES("123-456-7890", "\\d{3}-\\d{3}-\\d{4}") }} ``` O resultado esperado é: ``` true ``` ### **STRINGMATCHES** Retorna um array com todas as expressões correspondentes em uma string que satisfazem um padrão. #### **Sintaxe** {% code overflow="wrap" %} ``` STRINGMATCHES(value: string, pattern: string, patternFlag: string) -> Array[string] ``` {% endcode %} * `value`: a string onde as correspondências serão buscadas. * `pattern`: o padrão de expressão regular a ser usado na busca. * `patternFlag`: controla o comportamento do motor de expressão regular, como correspondência sem distinção de maiúsculas/minúsculas, correspondência multilinha ou sintaxe estendida. Se não especificado, o motor usa seu comportamento padrão. As opções são: | Flag | Descrição | | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `CANON_EQ` | Ativa a correspondência de equivalência canônica de caracteres Unicode. Caracteres que parecem idênticos são correspondidos mesmo que tenham codepoints Unicode diferentes. | | `CASE_INSENSITIVE` | Desativa a distinção entre maiúsculas e minúsculas. | | `COMMENTS` | Permite comentários no padrão de expressão regular. Comentários podem ser adicionados após o símbolo `#`. | | `DOTALL` | Ativa o modo "dotall", permitindo que o ponto `.` corresponda ao caractere de nova linha `\n`. | | `LITERAL` | Trata o padrão como uma sequência de caracteres literais. Metacaracteres e sequências de escape não têm significado especial. | | `MULTILINE` | Ativa a correspondência em múltiplas linhas. | | `UNICODE_CASE` | Permite a correspondência sem distinção de maiúsculas/minúsculas para caracteres Unicode, respeitando as regras de case folding Unicode. | | `UNICODE_CHARACTER_CLASS` | Permite o uso de classes de caracteres Unicode no padrão de expressão regular. | | `UNIX_LINES` | Altera o comportamento dos metacaracteres `^` e `$` para corresponder ao início e ao fim de uma linha, respectivamente, em vez do início e do fim da string de entrada. | **Retorna:** um array com todas as expressões correspondentes na string que satisfazem o padrão. #### **Exemplo de uso** ``` {{ STRINGMATCHES("Hello, world!", "hello", "CASE_INSENSITIVE") }} ``` O resultado esperado é: ``` ["Hello"] ``` ### **FUZZYMATCH** Realiza uma comparação aproximada entre uma string de referência e uma lista de candidatos com base em similaridade. #### **Sintaxe** ``` FUZZYMATCH(inputString, threshold, candidateOrArray1, candidateOrArray2, ...) ``` * **`inputString`**: A string de referência para comparação. Se `null`, é tratada como uma string vazia e a execução não é interrompida. * **`threshold`**: Um número entre `0` e `1` que define a similaridade mínima (por exemplo, 0.8 para 80%). O valor deve ser um número JSON, não uma string. Passar `"0.8"` (entre aspas) gera um erro de tipo. Valores fora do intervalo `[0, 1]` também geram um erro. * **`candidates`**: Um ou mais argumentos após o threshold, cada um podendo ser uma **string**, um **array JSON** ou qualquer outro valor JSON (números, booleanos, objetos). Valores não-string são convertidos para sua representação JSON em string antes da comparação. Quando um argumento é um array, cada um de seus elementos de primeiro nível é avaliado como um candidato independente. Escalares e arrays podem ser misturados na mesma chamada, e **pelo menos um candidato deve ser fornecido**.\ A expansão do array ocorre apenas no primeiro nível: se um elemento do array for ele mesmo um array ou um objeto, é tratado como um único candidato e sua serialização JSON é o que será comparado. **Retorna:** um array de strings contendo os candidatos com similaridade **maior ou igual ao** `threshold` fornecido, ordenados por **similaridade decrescente** (o mais similar primeiro). Os valores retornados preservam sua formatação original (maiúsculas/minúsculas e acentos). A similaridade é calculada como `1 −` (`distância de Levenshtein / comprimento máximo das strings normalizadas`). Uma pontuação de `1` significa strings idênticas (após normalização); uma pontuação de `0` significa strings completamente diferentes. {% hint style="info" %} Para o cálculo da pontuação, a função aplica a seguinte normalização tanto na string de entrada quanto em cada candidato antes de compará-los: * converte o texto para minúsculo (sem distinção de maiúsculas/minúsculas), * remove diacríticos (acentos), * substitui pontuação por espaços, * colapsa múltiplos espaços em um único espaço e remove espaços no início e no fim. A normalização afeta apenas o cálculo da pontuação. O texto original do candidato é preservado no array retornado. {% endhint %} #### **Exemplos de uso**
Correspondência com normalização (maiúsculas/minúsculas e acentos) Mesmo com diferenças de acentuação no candidato, a normalização permite uma correspondência se o threshold for atingido. * **Expressão:** `{{ FUZZYMATCH("ACME CORPORATION", 0.9, "ÁCME CORPÔRATION") }}` * **Resultado:** `["ÁCME CORPÔRATION"]`
Múltiplos candidatos com ordenação A função filtra os candidatos que não atingem o threshold mínimo e ordena os resultados pela pontuação de proximidade. * **Expressão:** `{{ FUZZYMATCH("Acme Corp", 0.5, "Globex", "Acme Corporation", "Aacme Corp") }}` * **Resultado:** `["Aacme Corp", "Acme Corporation"]`
Threshold restritivo (sem correspondência) Se nenhum candidato atingir a similaridade mínima, um array vazio é retornado. * **Expressão:** `{{ FUZZYMATCH("Apple", 0.9, "Pineapple", "Banana") }}` * **Resultado:** `[]`
Array como candidatos Passe uma variável de array diretamente. Cada elemento é avaliado como um candidato independente. * **Expressão:** `{{ FUZZYMATCH("ACME", 0.9999, message.array) }}` * **Resultado:** Elementos de `message.array` que atingem o threshold, ordenados por similaridade decrescente.
Candidatos escalares e de array misturados Escalares e arrays podem ser combinados na mesma chamada e são avaliados juntos. * **Expressão:** `{{ FUZZYMATCH("ACME", 0.9, "ACME FIXED", message.otherArray) }}` * **Resultado:** Todos os candidatos de ambas as fontes que atingem o threshold, ordenados por similaridade decrescente.
Array vazio Um array vazio não adiciona candidatos e não causa um erro. * **Expressão:** `{{ FUZZYMATCH("ACME", 0.99, []) }}` * **Resultado:** `[]`
Tratamento de erro de parâmetros A função requer pelo menos 3 parâmetros (entrada, threshold e 1 candidato). * **Expressão:** `{{ FUZZYMATCH("test", 0.8) }}` * **Resultado:** `Error: Wrong number of parameters for function FUZZYMATCH expected at least 3 mandatory but got 2`
Array aninhado (candidato único, sem expansão) Apenas o primeiro nível de um argumento do tipo array é expandido. Um array aninhado é tratado como um único candidato e sua serialização JSON é comparada. * **Expressão:** `{{ FUZZYMATCH("a,b", 0.99, [["a", "b"], "c"]) }}` * **Resultado:** `[]` O array interno `["a", "b"]` é comparado como a string literal `'["a","b"]'`, e não como os candidatos `"a"` e `"b"` separadamente.
Threshold inválido O threshold deve ser um número dentro do intervalo inclusivo `[0, 1]`. Qualquer outro valor gera um erro. * **Expressão:** `{{ FUZZYMATCH("a", 1.5, "a") }}` * **Resultado:** `Error: FUZZYMATCH threshold must be between 0 and 1, got 1.5`
Entrada nula é tratada como string vazia Entradas nulas não interrompem a execução. Elas são normalizadas para uma string vazia antes da comparação, e os candidatos são pontuados em relação a essa string vazia. * **Expressão:** `{{ FUZZYMATCH(null, 0.0, "anything") }}` * **Resultado:** `["anything"]` {% hint style="info" %} Com threshold `0`, todos os candidatos correspondem porque qualquer similaridade (incluindo `0.0`) satisfaz a condição. Com um threshold mais alto, o resultado é tipicamente `[]` porque a entrada vazia tem similaridade muito baixa em relação a candidatos não vazios. {% endhint %}
## **Concatenação e junção** ### **CONCAT** Concatena qualquer número de strings em uma única string. #### **Sintaxe** ``` CONCAT(*values: string) -> string ``` * `values`: qualquer número de strings a serem concatenadas. **Retorna:** a string concatenada. #### **Exemplo de uso** ``` {{ CONCAT("Hello", ", ", "world!") }} ``` O resultado esperado é: ``` "Hello, world!" ``` ### **CONCATWITHOUTTAB** Concatena duas ou mais strings e substitui todo caractere de tabulação (`\t`) por um único espaço ( ). #### **Sintaxe** ``` CONCATWITHOUTTAB([, , ..., ]) ``` * ``, ``, ..., ``: uma ou mais expressões de texto. * Os colchetes `[ ]` indicam que os parâmetros adicionais são opcionais. #### **Exemplo de uso** ``` "hi": {{ CONCATWITHOUTTAB("Hello", "\tWorld")}}} ``` O resultado esperado é: ```json { "hi": "Hello World" } ``` ### **JOIN** Concatena uma lista de strings em uma única string com um caractere separador especificado entre cada string. #### **Sintaxe** ``` JOIN(separator: string, *values: string) -> string ``` * `separator`: o caractere separador a ser usado entre cada string. * `values`: qualquer número de strings a serem concatenadas. **Retorna:** uma string representando a concatenação das strings de entrada com o caractere separador especificado entre cada uma. #### **Exemplos de uso**
Separador como espaço ``` {{ JOIN(" ", "These","words", "are", "separated","by","spaces") }} ``` O resultado esperado é: ``` "These words are separated by spaces" ```
Separador como hífen ``` {{ JOIN("-", "These","words", "are","separated","by","hyphens") }} ``` O resultado esperado é: ``` "These-words-are-separated-by-hyphens" ```
## **Transformação** ### **REPLACE** Substitui todas as ocorrências de uma substring em uma string com base em uma expressão regular. #### **Sintaxe** ``` REPLACE(value: string, pattern: string, replacement: string) -> string ``` * `value`: a string a ser pesquisada e alterada. * `pattern`: o padrão de expressão regular que especifica a substring a ser buscada. * `replacement`: a string que substituirá todas as ocorrências do padrão correspondente na string de entrada. #### **Exemplo de uso** ``` {{ REPLACE("Hello, world!", "Hello", "Bonjour") }} ``` O resultado esperado é: ``` "Bonjour, world!" ``` ### **SPLIT** Divide uma string em um array de strings com base em um padrão de expressão regular. #### **Sintaxe** ``` SPLIT(value: string, pattern: string) -> Array[string] ``` * `value`: a string a ser dividida. * `pattern`: o padrão de expressão regular que especifica o ponto de divisão. A string será dividida em todas as ocorrências do padrão. **Retorna:** um array de strings resultante da operação de divisão. #### **Exemplo de uso** ``` {{ SPLIT("Hello, world!", " ") }} ``` O resultado esperado é: ``` ["Hello,", "world!"] ``` ### **SUBSTRING** Extrai uma substring de uma string. #### **Sintaxe** {% code overflow="wrap" %} ``` SUBSTRING(value: string, start: int, end: int, throwIndexOutOfBoundError: boolean) -> string ``` {% endcode %} * `value`: a string original da qual a substring será extraída. * `start`: o índice inicial da substring. O índice começa em `0`. * `end`: o índice final da substring. Se não fornecido, a extração termina no último caractere da string original. * `throwIndexOutOfBoundError`: se `true`, um erro será lançado se os índices fornecidos estiverem fora do intervalo. Caso contrário, a string original será retornada. O padrão é `true`. **Retorna:** a substring extraída da string original. #### **Exemplo de uso** ``` {{ SUBSTRING("Hello, world!", 0, 5) }} ``` O resultado esperado é: ``` "Hello" ``` ### **TRIM** Remove espaços em branco no início e no fim de uma string. #### **Sintaxe** ``` TRIM(value : string) -> string ``` * `value`: a string a ser aparada. **Retorna:** uma string que é uma versão aparada de `value`. #### **Exemplo de uso** ``` {{ TRIM(" Hello, world! ") }} ``` O resultado esperado é: ``` "Hello, world!" ``` ### **LEFTPAD** Preenche o lado esquerdo de uma string com um caractere especificado até um comprimento específico. #### **Sintaxe** ``` LEFTPAD(value: string, length: integer, character:string) -> string ``` * `value`: a string de entrada a ser preenchida. * `length`: o comprimento desejado da string. * `character`: o caractere usado para preencher o lado esquerdo da string de entrada. O padrão é um espaço em branco. **Retorna:** uma string preenchida com o comprimento desejado, com o caractere especificado no lado esquerdo da string de entrada. Se a string de entrada já for maior que o comprimento especificado, a string original é retornada. #### **Exemplos de uso**
String menor que o comprimento alvo ``` {{ LEFTPAD("example", 10, "-") ``` O resultado esperado é: ``` "---example" ```
String já no comprimento alvo ``` {{ LEFTPAD("hello", 5, "*") ``` Como `"hello"` já tem 5 caracteres, o resultado esperado é: ``` "hello" ```
### **RIGHTPAD** Preenche o lado direito de uma string com um caractere especificado até um comprimento específico. #### **Sintaxe** ``` RIGHTPAD(value: string, length: integer, character:string) -> string ``` * `value`: a string de entrada a ser preenchida. * `length`: o comprimento desejado da string. * `character`: o caractere usado para preencher o lado direito da string de entrada. O padrão é um espaço em branco. **Retorna:** uma string preenchida com o comprimento desejado, com o caractere especificado no lado direito da string de entrada. Se a string de entrada já for maior que o comprimento especificado, a string original é retornada. #### **Exemplos de uso**
String menor que o comprimento alvo ``` {{ RIGHTPAD("example", 10, "-") }} ``` O resultado esperado é: ``` "Example---" ```
String já no comprimento alvo ``` {{ RIGHTPAD("hello", 5, "*") }} ``` Como `"hello"` já tem 5 caracteres, o resultado esperado é: ``` "hello" ```
## **Codificação** ### **ESCAPE** Codifica uma string usando sequências de escape. #### **Sintaxe** ``` ESCAPE(value: string, escapeType: string) -> string ``` * `value`: a string a ser codificada. * `escapeType`: o tipo de escape a ser usado. As opções válidas são `"JSON"`, `"XML"`, `"CSV"` e `"HTML"`. O padrão é `"JSON"`. **Retorna:** uma nova string na qual determinados caracteres foram escapados. #### **Exemplo de uso** ``` {{ ESCAPE("

Hello, world!

", "HTML") }} ``` O resultado esperado é: ``` "<h1>Hello, world!</h1>" ``` ### **UNESCAPE** Decodifica uma string que contém sequências de escape. #### **Sintaxe** ``` UNESCAPE(value: string, escapeType: string) -> string ``` * `value`: a string a ser decodificada. * `escapeType`: o tipo de escape a ser usado. As opções válidas são `"JSON"`, `"XML"`, `"CSV"` e `"HTML"`. O padrão é `"JSON"`. **Retorna:** uma nova string na qual determinados caracteres foram desescapados. #### **Exemplo de uso** ``` {{ UNESCAPE("<h1>Hello, world!</h1>", "HTML") }} ``` O resultado esperado é: ``` "

Hello, world!

" ``` ## **Utilitários** ### **DEFAULT** Retorna um valor padrão quando uma referência aponta para um valor nulo ou inexistente. #### **Sintaxe** ``` DEFAULT(value : string, defaultValue : string) -> string ``` * `value`: o valor a ser verificado quanto à nulidade ou inexistência. * `defaultValue`: o valor padrão a ser retornado se `value` for nulo ou inexistente. **Retorna:** `value`, se `value` não for nulo ou inexistente, ou `defaultValue`, caso contrário. #### **Exemplo de uso** Suponha que você esteja usando esta função no parâmetro JSON de um componente JSON Generator que recebe o seguinte payload: ```json { "name" : "John Doe", "age" : null } ``` Você pode usar a função DEFAULT para substituir o valor nulo pela string "not available". ```json { "name" : "John Doe", "age" : {{ DEFAULT(message.age, "not available") }} } ``` O resultado esperado é: ```json { "name" : "John Doe", "age" : "not available" } ``` Leia este artigo para saber mais sobre [como referenciar dados com Double Braces](/documentation/connectors-and-triggers/pt-br/double-braces/how-to-reference-data-using-double-braces.md). ### **TOSTRING** Converte um objeto para sua representação em string. #### **Sintaxe** ``` TOSTRING(object: any) -> string ``` * `object`: o objeto a ser convertido para string. Pode ser de qualquer tipo. #### **Exemplo de uso** ``` {{ TOSTRING(123) }} ``` O resultado esperado é: ``` "123" ``` ### **RANDOMSTRINGS** Gera strings aleatórias a partir de um charset e comprimento especificados. #### **Sintaxe** ``` RANDOMSTRINGS(charset: string, length: int) -> string ``` * `charset`: o charset a ser usado. As opções são: `"ALPHANUMERIC"`, `"ALPHABETIC"`, `"ASCII"` e `"NUMERIC"`. * `length`: o comprimento da string de saída. #### **Exemplo de uso** ``` {{ RANDOMSTRINGS("ALPHANUMERIC",10) }} ``` O resultado varia porque é aleatório. Um possível resultado é: ``` "lUbCIs7T3G" ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/double-braces/double-braces-functions/string-functions.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.