> 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/conditional-functions.md).
# Funções de condição
As funções condicionais retornam um valor de acordo com o critério que você estabeleceu 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, leia a documentação [Funções *Double Braces*](/documentation/connectors-and-triggers/pt-br/double-braces/double-braces-functions.md).
## EQUALTO
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função compara dois objetos (que podem ser números, *strings*, *arrays*, etc.) e verifica se são iguais.
### **Sintaxe**
```
EQUALTO(obj1, obj2 )
```
Vamos supor que você precise validar se este objeto
```
{
"body1":{
"cep": “01200-030”
}
}
```
é igual a este:
```
{
"body2":{
"CEP": “01200-030”
}
}
```
No exemplo abaixo o valor `false` será atribuído, pois os objetos são diferentes:
```
{
"valid": {{ EQUALTO( message.body1, message.body2 ) }}
}
```
{% hint style="info" %}
O retorno dessa função será `true` ou `false`.
{% endhint %}
## GREATERTHAN
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função compara se o primeiro número é maior que o segundo.
### **Sintaxe**
```
GREATERTHAN(num1, num2)
```
### **Payload**
```
{
"num1": 1,
"num2": 2
}
```
No exemplo abaixo o valor "false" será atribuído:
```
{
"valid": {{ GREATERTHAN( message.num1, message.num2 ) }}
}
```
O valor *null* é considerado como o menor valor possível para comparação.
GREATERTHAN( null, null ) retornará "false".
{% hint style="info" %}
O retorno dessa função será `true` ou `false`.
{% endhint %}
## GREATERTHANEQUAL
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função compara se o primeiro número é maior ou igual ao segundo.
### **Sintaxe**
```
GREATERTHANEQUAL(num1, num2 )
```
### **Payload**
```
{
"num1": 1,
"num2": 2
}
```
No exemplo abaixo o valor `false` será atribuído:
```
{
"valid": {{ GREATERTHANEQUAL( message.num1, message.num2 ) }}
}
```
O valor `null` é considerado como o menor valor possível para comparação.
`GREATERTHANEQUAL(null, null)` retornará `true`.
{% hint style="info" %}
O retorno dessa função será `true` ou `false`.
{% endhint %}
## IF
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você faça comparações lógicas entre um valor e aquilo que você espera.
Portanto, uma instrução IF pode ter 2 resultados. O primeiro resultado acontece quando a comparação é verdadeira e o segundo quando a comparação é falsa.
### **Sintaxe**
```
IF(comparação, valor-se-verdadeiro, valor-se-falso)
```
Vamos supor que você precise tomar decisões dependendo se o valor recebido é `true` ou `false`:
```
{
"boolean": false
}
```
No exemplo abaixo o valor da condição (valor-se-falso) será atribuído ao JSON:
```
{
"cep": {{ IF( message.boolean, "cep-ok", "cep-nao-ok" ) }}
}
```
{% hint style="info" %}
O retorno dessa função será qualquer valor passado nas mensagens da condicional `true`/`false`.
{% endhint %}
## LESSTHAN
Utilizando *Double Brace*s, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função compara se o primeiro número é menor que o segundo.
### **Sintaxe**
```
LESSTHAN(num1, num2 )
```
### **Payload**
```
{
"num1": 1,
"num2": 2
}
```
No exemplo abaixo o valor "true" será atribuído:
```
{
"valid": {{ LESSTHAN( message.num1, message.num2 ) }}
}
```
O valor `null` é considerado como o menor valor possível para comparação.
`LESSTHAN(null, null)` retornará `false`.
{% hint style="info" %}
O retorno dessa função será `true` ou `false`.
{% endhint %}
## LESSTHANEQUAL
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função compara se o primeiro número é menor ou igual ao segundo.
### **Sintaxe**
```
LESSTHANEQUAL(num1, num2)
```
### **Payload**
```
{
"num1": 1,
"num2": 2
}
```
No exemplo abaixo o valor `true` será atribuído:
```
{
"valid": {{ LESSTHANEQUAL( message.num1, message.num2 ) }}
}
```
O valor `null` é considerado como o menor valor possível para comparação.
`LESSTHANEQUAL(null, null)` retornará `true`.
{% hint style="info" %}
O retorno dessa função será `true` ou `false`.
{% endhint %}
## ISOBJECT
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é um objeto.
**Sintaxe**
```
ISOBJECT(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é um objeto:
```
{
"argument": false
}
```
Validando o argumento:
```
{
"isObject": {{ ISOBJECT( message.argument) }}
}
```
O retorno será `false`, pois o valor não é um objeto.
Agora passando um objeto para a função:
```
{
"argument": {
"test": "xpto"
}
}
```
Validando o argumento:
```
{
"isObject": {{ ISOBJECT( message.argument) }}
}
```
O retorno será `true`.
## ISARRAY
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é um *array*.
**Sintaxe**
```
ISARRAY(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é um *array*:
```
{
"argument": false
}
```
Validando o argumento:
```
{
"isObject": {{ ISARRAY( message.argument) }}
}
```
O retorno será `false`, pois o valor não é um *array*.
Agora passando um objeto para a função:
```
{
"argument": [{
"test": "xpto"
}]
}
```
Validando o argumento:
```
{
"isArray": {{ ISARRAY( message.argument) }}
}
```
O retorno será `true`.
## ISBOOLEAN
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é um valor booleano.
### **Sintaxe**
```
ISBOOLEAN(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é um valor booleano:
```
{
"argument": false
}
```
Validando o argumento:
```
{
"isObject": {{ ISBOOLEAN( message.argument) }}
}
```
O retorno será `true`, pois o valor é booleano.
Agora passando um objeto para a função:
```
{
"argument": {
"test": "xpto"
}
}
{"isBoolean": {{ ISBOOLEAN( message.argument) }}}
```
Validando o argumento:
```
{
"isBoolean": {{ ISBOOLEAN( message.argument) }}
}
```
O retorno será `false`.
## ISSTRING
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é uma *string*.
### **Sintaxe**
```
ISSTRING(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é uma *string*:
```
{
"argument": "test"
}
```
Validando o argumento:
```
{
"isString": {{ ISSTRING( message.argument) }}
}
```
O retorno será `true`, pois o valor é uma *string*.
## ISNUMBER
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é um número.
### **Sintaxe**
```
ISNUMBER(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é um número:
```
{
"argument": 123
}
```
Validando o argumento:
```
{
"isNumber": {{ ISNUMBER( message.argument) }}
}
```
O retorno será `true`, pois o valor é um número.
## ISNULL
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você verifique se o argumento passado é `null`.
### **Sintaxe**
```
ISNULL(objeto)
```
Vamos supor que você precise verificar se o argumento recebido é um valor *null*:
```
{
"argument": null
}
```
Validando o argumento:
```
{
"isNull": {{ ISNULL( message.argument) }}
}
```
O retorno será `true`, pois o valor é um valor *null*.
## SWITCHCASE
Utilizando *Double Braces*, você pode combinar a função com o acesso ao elemento do JSON de entrada de um componente.
A função permite que você passe várias comparações e os devidos parâmetros que devem ser retornados caso alguma dessas validações retorne `true`. Se nenhuma validação retornar `true`, valor padrão configurado será utilizado.
### **Sintaxe**
```
SWITCHCASE(defaultValue, condition1, result1, condition2, result2, …., conditionN, resultN)
```
Vamos supor que você precise validar algumas condições para tomada de decisão:
```
{
"argument": null
}
```
Validando o argumento:
```
{
"result": {{ SWITCHCASE("failed", ISNULL(message.argument), "ok", ISNUMBER(message.argument), "nok" ) }}
}
```
Portanto, a configuração da função ficará:
**Valor default:** "failed"
**Condition 1:** ISNULL(message.argument)
**Result If Condition 1 Matches:** "ok"
**Condition 2:** ISNUMBER(message.argument)
**Result If Condition 2 Matches:** "nok"
O retorno será "ok", pois a primeira condição foi atendida.
### ISABSENT
A função normaliza valores ausentes aplicando a seguinte regra:
* Se o valor for considerado ausente, retorna `null`.
* Caso contrário, o valor original é retornado sem alterações.
#### Sintaxe
```
ISABSENT(value)
```
#### Comportamento
Um valor é considerado ausente quando é:
* `null`
* uma string vazia (`""`)
* uma string contendo apenas espaços em branco (por exemplo, `" "`, `" "`)
* um objeto vazio (`{}`)
* um array vazio (`[]`)
* um campo inexistente
#### Exemplos
Veja a tabela abaixo para alguns exemplos:
| Entrada | Tipo | Saída |
|---|
ISABSENT(null) | Valor nulo | null |
ISABSENT("") | String vazia | null |
ISABSENT(" ") | String com espaço | null |
ISABSENT({}) | Objeto vazio | null |
ISABSENT([]) | Array vazio | null |
ISABSENT(payload.age) | Campo inexistente | null |
| ISABSENT("John") | String com valor | "John" |
| ISABSENT("100") | Valor numérico | 100 |
---
# 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/conditional-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.