> 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/hablla-docs-es/flujos-de-automatizaciones/usando-variables.md).

# Usando variables

En Hablla, al configurar un flujo de automatización, puedes utilizar **variables** para recuperar datos de componentes anteriores y expresiones **lógicas y condicionales** para hacer tus automatizaciones más dinámicas e inteligentes.

Esto permite que la información se reutilice automáticamente, sin necesidad de rellenarla manualmente, haciendo el proceso más eficiente y sin errores.

### 🎯 **¿Qué son las Variables en Hablla?**

Cada componente dentro de un flujo tiene un **código único** y puede generar **datos de salida** que pueden ser usados por otros componentes en el mismo flujo.

<figure><img src="https://4006966930-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>

Puedes acceder a estos datos usando la siguiente sintaxis:

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

➡ **Ejemplo real:**\
Si un componente llamado `whatsappReceptive_tmy0de` identificó a una persona, y su ID está almacenado dentro del campo `person.id`, podemos acceder a ese valor así:

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

Si ese componente no devuelve un valor válido, podemos probar un segundo componente llamado `whatsappReceptive_r2b7wr`:

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

📌 Aquí, `??` significa: **si el primer valor es nulo o indefinido, usa el segundo.**

***

### 🔥 **Operadores y Expresiones en Hablla**

Además de acceder a variables, puedes usar **operadores lógicos** para crear reglas y condiciones dentro de tus flujos.

#### 🛠 Operadores Lógicos y Condicionales

| Operador                                               | Significado                                                                           | Ejemplo                                                      |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| `??` (Coalescencia nula - "Si es nulo o indefinido")   | Si el primer valor es nulo o indefinido, usa el segundo                               | `{{$data?.componente1?.valor ?? $data?.componente2?.valor}}` |
| \|\| (OR lógico - "O")                                 | Si el primer valor es falso (`false`, `null`, `undefined`, `0`, `""`), usa el segundo | {{$data?.status \|\| "Pendiente"}}                           |
| `:` (Operador ternario - "Si... entonces... si no...") | Funciona como un operador ternario (if/else)                                          | `{{$data?.idade > 18 ? "Mayor de edad" : "Menor de edad"}}`  |
| `&&` (AND lógico - "Y")                                | Devuelve el segundo valor si el primero es verdadero                                  | `{{$data?.temDesconto && "Descuento aplicado"}}`             |

***

| Operador             | Significado                       | Ejemplo            |
| -------------------- | --------------------------------- | ------------------ |
| `+` (Adición)        | Suma dos valores.                 | `{{5 + 3}}` → `8`  |
| `-` (Sustracción)    | Resta dos valores.                | `{{10 - 4}}` → `6` |
| `*` (Multiplicación) | Multiplica dos valores.           | `{{3 * 4}}` → `12` |
| `/` (División)       | Divide dos valores.               | `{{10 / 2}}` → `5` |
| `%` (Módulo)         | Devuelve el resto de la división. | `{{10 % 3}}` → `1` |

***

#### 🔍 **Operadores de Comparación**

| Operador                        | Significado                                                         | Ejemplo                   |
| ------------------------------- | ------------------------------------------------------------------- | ------------------------- |
| `==` (Igualdad)                 | Compara valores sin verificar el tipo.                              | `{{5 == "5"}}` → `true`   |
| `===` (Estríctamente igual)     | Compara valores y el tipo de dato.                                  | `{{5 === "5"}}` → `false` |
| `!=` (Diferente)                | Compara si los valores son diferentes.                              | `{{5 != "5"}}` → `false`  |
| `!==` (Estríctamente diferente) | Compara si los valores y los tipos son diferentes.                  | `{{5 !== "5"}}` → `true`  |
| `>` (Mayor que)                 | Devuelve `true` si el primer valor es mayor que el segundo.         | `{{10 > 5}}` → `true`     |
| `<` (Menor que)                 | Devuelve `true` si el primer valor es menor que el segundo.         | `{{3 < 7}}` → `true`      |
| `>=` (Mayor o igual)            | Devuelve `true` si el primer valor es mayor o igual que el segundo. | `{{8 >= 8}}` → `true`     |
| `<=` (Menor o igual)            | Devuelve `true` si el primer valor es menor o igual que el segundo. | `{{6 <= 5}}` → `false`    |

***

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

| Operador            | Significado      | Ejemplo                                       |
| ------------------- | ---------------- | --------------------------------------------- |
| `+` (Concatenación) | Une dos strings. | `{{"Hola, " + "mundo!"}}` → `"¡Hola, mundo!"` |

***

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

| Operador      | Significado                                    | Ejemplo                                    |
| ------------- | ---------------------------------------------- | ------------------------------------------ |
| `.length`     | Devuelve el tamaño de un array.                | `{{$data?.nomes.length}}`                  |
| `.includes()` | Verifica si un valor existe en el array.       | `{{$data?.cidades.includes("São Paulo")}}` |
| `.map()`      | Itera sobre los elementos y modifica el array. | `{{$data?.numeros.map(n => n * 2)}}`       |
| `.filter()`   | Filtra elementos del array.                    | `{{$data?.numeros.filter(n => n > 5)}}`    |

### 🔍 **Cómo Usar Condiciones IF/ELSE**

En Hablla, puedes crear **reglas condicionales** dentro de los flujos. Mira cómo funciona:

#### ✅ **Ejemplo 1: Verificar si un cliente está calificado**

```plaintext
{{$data?.lead?.score > 50 ? "Lead calificado" : "Lead no calificado"}}
```

Si el score del lead es **mayor que 50**, el resultado será `"Lead calificado"`, de lo contrario, `"Lead no calificado"`.

#### ✅ **Ejemplo 2: Definir un estado predeterminado**

```plaintext
{{$data?.pedido?.status ?? "En proceso"}}
```

Si el estado del pedido existe, se utilizará. De lo contrario, el estado predeterminado `"En proceso"` se aplicará.

#### ✅ **Ejemplo 3: Combinar múltiples condiciones**

```plaintext
{{$data?.usuario?.idade >= 18 ? "Mayor de edad" : $data?.usuario?.idade > 0 ? "Menor de edad" : "Edad no informada"}}
```

🔹 Si la edad es mayor o igual a **18**, el resultado será `"Mayor de edad"`.\
🔹 Si la edad es mayor que **0**, pero menor que **18**, el resultado será `"Menor de edad"`.\
🔹 Si la edad no está informada, el resultado será `"Edad no informada"`.

***

### 🎯 **Cómo Utilizar Estas Expresiones en la Configuración de un Componente**

Siempre que estés configurando un componente en Hablla, puedes usar estas expresiones en los campos donde deseas insertar valores dinámicos.

📌 **Ejemplo práctico:**\
Supongamos que estamos creando una nueva tarjeta en el flujo y queremos asociarle una persona identificada en un componente anterior. Podemos hacerlo así:

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

Esto garantiza que, si un componente no encuentra a la persona, el otro se utilizará automáticamente.

## Buenas prácticas en el uso de variables

Al utilizar variables en flujos de automatización, es importante entender la diferencia entre **identificadores únicos** y **atributos descriptivos**.

Algunos campos representan características de una entidad y pueden cambiar con el tiempo, como:

```
name
std_name
status
description
```

Otros campos existen específicamente para identificar una entidad de forma única, como:

```
id
```

### Prefiere `id` para referencias permanentes

Siempre que una automatización necesite identificar una entidad específica — por ejemplo, una etiqueta, persona, lista, sector, tarjeta u otro objeto —, prefiere utilizar el campo `id`.

Ejemplo:

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

El `id` es la referencia más adecuada para automatizaciones que necesitan mantenerse estables con el tiempo.

Esto evita que los cambios de registro afecten la lógica del flujo.

### Usa atributos descriptivos para comparar valores

Campos como `name` y `std_name` pueden utilizarse normalmente cuando el objetivo de la automatización es evaluar el contenido actual de una propiedad.

Ejemplo:

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

o:

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

En este caso, la automatización está comparando intencionalmente el valor de ese atributo.

La diferencia está en el objetivo de la condición:

* para identificar una entidad específica, usa `id`;
* para evaluar una característica de la entidad, usa el atributo correspondiente.

### ¿Por qué esto es importante?

Los atributos descriptivos pueden cambiar durante el ciclo de vida de la entidad.

Por ejemplo, un nombre puede editarse posteriormente sin que el objeto deje de ser el mismo.

El identificador sigue representando la misma entidad:

```
id = entidad específica
name = característica actual de la entidad
std_name = representación normalizada del nombre
```

Por eso, una automatización construida con base en el `id` tiende a ser más resistente a cambios futuros.

### Ejemplo genérico

Considera una entidad con los siguientes datos:

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

Para identificar permanentemente esa entidad:

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

Para verificar si el nombre actual es `"Cliente VIP"`:

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

Son dos usos diferentes.

El primero identifica el objeto.

El segundo compara una propiedad del objeto.

### Regla recomendada

Para construir automatizaciones más robustas:

```
Identificación de entidad → usa id
Comparación de atributos → usa el atributo correspondiente
```

Siempre que haya un `id` disponible y la intención sea referenciar una entidad específica, debe ser la opción preferida.

> **Buena práctica:** siempre que necesites crear una referencia permanente a una entidad dentro de una automatización, prefiere utilizar el campo `id`. Campos como `name` y `std_name` deben utilizarse cuando la intención sea comparar sus valores actuales.

***

### 🔥 **Resumen: Cómo Usar Variables y Expresiones en Hablla**

✅ **Usa `{{$data?.codigoDoComponente?.caminhoVariavel}}`** para acceder a datos de componentes anteriores.\
✅ **Usa `??` para definir un valor alternativo si el primero es nulo o indefinido.**\
✅ **Usa `||` para definir un valor alternativo si el primero es falso.**\
✅ **Usa `:` para crear reglas `if/else` dentro de los campos.**\
✅ **Usa `&&` para definir un valor solo si la condición es verdadera.**

🚀 **¡Con estas técnicas, puedes crear flujos inteligentes y personalizados sin necesidad de 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/hablla-docs-es/flujos-de-automatizaciones/usando-variables.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.