> For the complete documentation index, see [llms.txt](https://docs.hablla.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.hablla.com/fluxos-de-automacoes/usando-variaveis.md).

# Usando variáveis

Na Hablla, ao configurar um fluxo de automação, você pode utilizar **variáveis** para recuperar dados de componentes anteriores e expressões **lógicas e condicionais** para tornar suas automações mais dinâmicas e inteligentes.

Isso permite que informações sejam reutilizadas automaticamente, sem precisar preenchê-las manualmente, tornando o processo mais eficiente e sem erros.

### 🎯 **O Que São Variáveis na Hablla?**

Cada componente dentro de um fluxo tem um **código único** e pode gerar **dados de saída** que podem ser usados por outros componentes no mesmo fluxo.

<figure><img src="https://1879311494-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FrmxWrIrMauHcIrsuqfGq%2Fuploads%2FWpztEh7gCvaKUGA9aENC%2Fimage.png?alt=media&amp;token=f7845359-1265-4bad-91a6-7b747e789e21" alt=""><figcaption></figcaption></figure>

Você pode acessar esses dados usando a seguinte sintaxe:

```plaintext
{{$data?.codigoDoComponente?.caminhoVariavel}}
```

➡ **Exemplo real:**\
Se um componente chamado `whatsappReceptive_tmy0de` identificou uma pessoa, e o ID dela está armazenado dentro do campo `person.id`, podemos acessar esse valor assim:

```plaintext
{{$data?.whatsappReceptive_tmy0de?.person?.id}}
```

Se esse componente não retornar um valor válido, podemos tentar um segundo componente chamado `whatsappReceptive_r2b7wr`:

```plaintext
{{$data?.whatsappReceptive_tmy0de?.person?.id ?? $data?.whatsappReceptive_r2b7wr?.person?.id}}
```

📌 Aqui, `??` significa: **se o primeiro valor for nulo ou indefinido, use o segundo.**

***

### 🔥 **Operadores e Expressões na Hablla**

Além de acessar variáveis, você pode usar **operadores lógicos** para criar regras e condições dentro dos seus fluxos.

#### 🛠 Operadores Lógicos e Condicionais

| Operador                                            | Significado                                                                            | Exemplo                                                       |
| --------------------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| `??` (Nullish Coalescing - "Se nulo ou indefinido") | Se o primeiro valor for nulo ou indefinido, use o segundo                              | `{{$data?.componente1?.valor ?? $data?.componente2?.valor}}`  |
| \|\| (Logical OR - "Ou")                            | Se o primeiro valor for falso (`false`, `null`, `undefined`, `0`, `""`), usa o segundo | {{$data?.status \|\| "Pendente"}}                             |
| `:` (Operador ternário - "Se... então... senão")    | Funciona como um operador ternário (if/else)                                           | `{{$data?.idade > 18 ? "Maior de idade" : "Menor de idade"}}` |
| `&&` (Logical AND - "E")                            | Retorna o segundo valor se o primeiro for verdadeiro                                   | `{{$data?.temDesconto && "Desconto Aplicado"}}`               |

***

| Operador            | Significado                 | Exemplo            |
| ------------------- | --------------------------- | ------------------ |
| `+` (Adição)        | Soma dois valores.          | `{{5 + 3}}` → `8`  |
| `-` (Subtração)     | Subtrai dois valores.       | `{{10 - 4}}` → `6` |
| `*` (Multiplicação) | Multiplica dois valores.    | `{{3 * 4}}` → `12` |
| `/` (Divisão)       | Divide dois valores.        | `{{10 / 2}}` → `5` |
| `%` (Módulo)        | Retorna o resto da divisão. | `{{10 % 3}}` → `1` |

***

#### 🔍 **Operadores de Comparação**

| Operador                       | Significado                                                       | Exemplo                   |
| ------------------------------ | ----------------------------------------------------------------- | ------------------------- |
| `==` (Igualdade)               | Compara valores sem verificar o tipo.                             | `{{5 == "5"}}` → `true`   |
| `===` (Estritamente igual)     | Compara valores e o tipo de dado.                                 | `{{5 === "5"}}` → `false` |
| `!=` (Diferente)               | Compara se os valores são diferentes.                             | `{{5 != "5"}}` → `false`  |
| `!==` (Estritamente diferente) | Compara se os valores e os tipos são diferentes.                  | `{{5 !== "5"}}` → `true`  |
| `>` (Maior que)                | Retorna `true` se o primeiro valor for maior que o segundo.       | `{{10 > 5}}` → `true`     |
| `<` (Menor que)                | Retorna `true` se o primeiro valor for menor que o segundo.       | `{{3 < 7}}` → `true`      |
| `>=` (Maior ou igual)          | Retorna `true` se o primeiro valor for maior ou igual ao segundo. | `{{8 >= 8}}` → `true`     |
| `<=` (Menor ou igual)          | Retorna `true` se o primeiro valor for menor ou igual ao segundo. | `{{6 <= 5}}` → `false`    |

***

#### 🔄 **Operadores de String**

| Operador           | Significado         | Exemplo                                    |
| ------------------ | ------------------- | ------------------------------------------ |
| `+` (Concatenação) | Junta duas strings. | `{{"Olá, " + "mundo!"}}` → `"Olá, mundo!"` |

***

#### 🔀 **Operadores de Arrays**

| Operador      | Significado                                  | Exemplo                                    |
| ------------- | -------------------------------------------- | ------------------------------------------ |
| `.length`     | Retorna o tamanho de um array.               | `{{$data?.nomes.length}}`                  |
| `.includes()` | Verifica se um valor existe no array.        | `{{$data?.cidades.includes("São Paulo")}}` |
| `.map()`      | Itera sobre os elementos e modifica o array. | `{{$data?.numeros.map(n => n * 2)}}`       |
| `.filter()`   | Filtra elementos do array.                   | `{{$data?.numeros.filter(n => n > 5)}}`    |

### 🔍 **Como Usar Condições IF/ELSE**

Na Hablla, você pode criar **regras condicionais** dentro dos fluxos. Veja como funciona:

#### ✅ **Exemplo 1: Verificar se um cliente está qualificado**

```plaintext
{{$data?.lead?.score > 50 ? "Lead Qualificado" : "Lead Não Qualificado"}}
```

Se o score do lead for **maior que 50**, o resultado será `"Lead Qualificado"`, caso contrário, `"Lead Não Qualificado"`.

#### ✅ **Exemplo 2: Definir um status padrão**

```plaintext
{{$data?.pedido?.status ?? "Em processamento"}}
```

Se o status do pedido existir, ele será utilizado. Caso contrário, o status padrão `"Em processamento"` será aplicado.

#### ✅ **Exemplo 3: Combinar múltiplas condições**

```plaintext
{{$data?.usuario?.idade >= 18 ? "Maior de idade" : $data?.usuario?.idade > 0 ? "Menor de idade" : "Idade não informada"}}
```

🔹 Se a idade for maior ou igual a **18**, o resultado será `"Maior de idade"`.\
🔹 Se a idade for maior que **0**, mas menor que **18**, o resultado será `"Menor de idade"`.\
🔹 Se a idade não estiver informada, o resultado será `"Idade não informada"`.

***

### 🎯 **Como Utilizar Essas Expressões na Configuração de um Componente**

Sempre que estiver configurando um componente na Hablla, você pode usar essas expressões nos campos onde deseja inserir valores dinâmicos.

📌 **Exemplo prático:**\
Suponha que estamos criando um novo cartão no fluxo e queremos associar a ele uma pessoa identificada em um componente anterior. Podemos fazer isso assim:

```plaintext
{{$data?.whatsappReceptive_tmy0de?.person?.id ?? $data?.whatsappReceptive_r2b7wr?.person?.id}}
```

Isso garante que, se um componente não encontrar a pessoa, o outro será usado automaticamente.

## Boas práticas no uso de variáveis

Ao utilizar variáveis em fluxos de automação, é importante entender a diferença entre **identificadores únicos** e **atributos descritivos**.

Alguns campos representam características de uma entidade e podem ser alterados ao longo do tempo, como:

```
name
std_name
status
description
```

Outros campos existem especificamente para identificar uma entidade de forma única, como:

```
id
```

### Prefira `id` para referências permanentes

Sempre que uma automação precisar identificar uma entidade específica — por exemplo, uma tag, pessoa, lista, setor, card ou outro objeto — prefira utilizar o campo `id`.

Exemplo:

```
{{$data?.componente?.id === "IDENTIFICADOR_DA_ENTIDADE"}}
```

O `id` é a referência mais adequada para automações que precisam permanecer estáveis ao longo do tempo.

Isso evita que alterações cadastrais afetem a lógica do fluxo.

### Use atributos descritivos para comparar valores

Campos como `name` e `std_name` podem ser utilizados normalmente quando o objetivo da automação for avaliar o conteúdo atual de uma propriedade.

Exemplo:

```
{{$data?.componente?.status === "active"}}
```

ou:

```
{{$data?.componente?.name === "Cliente Premium"}}
```

Nesse caso, a automação está propositalmente comparando o valor daquele atributo.

A diferença está no objetivo da condição:

* para identificar uma entidade específica, use `id`;
* para avaliar uma característica da entidade, use o atributo correspondente.

### Por que isso é importante?

Atributos descritivos podem mudar durante o ciclo de vida da entidade.

Por exemplo, um nome pode ser editado posteriormente sem que o objeto deixe de ser o mesmo.

O identificador continua representando a mesma entidade:

```
id = entidade específica
name = característica atual da entidade
std_name = representação normalizada do nome
```

Por isso, uma automação construída com base no `id` tende a ser mais resiliente a alterações futuras.

### Exemplo genérico

Considere uma entidade com os seguintes dados:

```
{
  "id": "abc123",
  "name": "Cliente VIP",
  "std_name": "cliente_vip"
}
```

Para identificar permanentemente essa entidade:

```
{{$data?.componente?.id === "abc123"}}
```

Para verificar se o nome atual é `"Cliente VIP"`:

```
{{$data?.componente?.name === "Cliente VIP"}}
```

São dois usos diferentes.

O primeiro identifica o objeto.

O segundo compara uma propriedade do objeto.

### Regra recomendada

Para construir automações mais robustas:

```
Identificação de entidade → use id
Comparação de atributos → use o atributo correspondente
```

Sempre que houver um `id` disponível e a intenção for referenciar uma entidade específica, ele deve ser a opção preferencial.

> **Boa prática:** sempre que precisar criar uma referência permanente a uma entidade dentro de uma automação, prefira utilizar o campo `id`. Campos como `name` e `std_name` devem ser utilizados quando a intenção for comparar seus valores atuais.

***

### 🔥 **Resumo: Como Usar Variáveis e Expressões na Hablla**

✅ **Use `{{$data?.codigoDoComponente?.caminhoVariavel}}`** para acessar dados de componentes anteriores.\
✅ **Use `??` para definir um valor alternativo caso o primeiro seja nulo ou indefinido.**\
✅ **Use `||` para definir um valor alternativo caso o primeiro seja falso.**\
✅ **Use `:` para criar regras `if/else` dentro dos campos.**\
✅ **Use `&&` para definir um valor somente se a condição for verdadeira.**

🚀 **Com essas técnicas, você pode criar fluxos inteligentes e personalizados sem precisar programar!**


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.hablla.com/fluxos-de-automacoes/usando-variaveis.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
