# 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*](https://docs.digibee.com/documentation/connectors-and-triggers/pt-br/double-braces/double-braces-functions).
## 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 |