> 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/french/flux-dautomatisations/utilisation-des-variables.md).

# Utilisation des variables

Dans Hablla, lors de la configuration d'un flux d'automatisation, vous pouvez utiliser **des variables** pour récupérer des données de composants précédents et des expressions **logiques et conditionnelles** pour rendre vos automatisations plus dynamiques et intelligentes.

Cela permet de réutiliser automatiquement les informations, sans avoir à les saisir manuellement, rendant le processus plus efficace et sans erreurs.

### 🎯 **Que sont les variables dans Hablla ?**

Chaque composant dans un flux a un **code unique** et peut générer **des données de sortie** qui peuvent être utilisées par d'autres composants dans le même flux.

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

Vous pouvez accéder à ces données en utilisant la syntaxe suivante :

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

➡ **Exemple concret :**\
Si un composant appelé `whatsappReceptive_tmy0de` a identifié une personne, et son ID est stocké dans le champ `person.id`, nous pouvons accéder à cette valeur ainsi :

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

Si ce composant ne renvoie pas une valeur valide, nous pouvons essayer un deuxième composant appelé `whatsappReceptive_r2b7wr`:

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

📌 Ici, `??` signifie : **si la première valeur est nulle ou indéfinie, utilisez la seconde.**

***

### 🔥 **Opérateurs et expressions dans Hablla**

En plus d'accéder aux variables, vous pouvez utiliser **des opérateurs logiques** pour créer des règles et des conditions dans vos flux.

#### 🛠 Opérateurs logiques et conditionnels

| Opérateur                                         | Signification                                                                                   | Exemple                                                      |
| ------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| `??` (Coalescence nulle - "Si nul ou indéfini")   | Si la première valeur est nulle ou indéfinie, utilisez la seconde                               | `{{$data?.componente1?.valor ?? $data?.componente2?.valor}}` |
| \|\| (OU logique - "Ou")                          | Si la première valeur est fausse (`false`, `null`, `undefined`, `0`, `""`), utilisez la seconde | {{$data?.status \|\| "En attente"}}                          |
| `:` (Opérateur ternaire - "Si... alors... sinon") | Fonctionne comme un opérateur ternaire (if/else)                                                | `{{$data?.idade > 18 ? "Majeur" : "Mineur"}}`                |
| `&&` (ET logique - "Et")                          | Renvoie la deuxième valeur si la première est vraie                                             | `{{$data?.temDesconto && "Remise appliquée"}}`               |

***

| Opérateur            | Signification                    | Exemple            |
| -------------------- | -------------------------------- | ------------------ |
| `+` (Addition)       | Additionne deux valeurs.         | `{{5 + 3}}` → `8`  |
| `-` (Soustraction)   | Soustrait deux valeurs.          | `{{10 - 4}}` → `6` |
| `*` (Multiplication) | Multiplie deux valeurs.          | `{{3 * 4}}` → `12` |
| `/` (Division)       | Divise deux valeurs.             | `{{10 / 2}}` → `5` |
| `%` (Modulo)         | Renvoie le reste de la division. | `{{10 % 3}}` → `1` |

***

#### 🔍 **Opérateurs de comparaison**

| Opérateur                     | Signification                                                              | Exemple                   |
| ----------------------------- | -------------------------------------------------------------------------- | ------------------------- |
| `==` (Égalité)                | Compare les valeurs sans vérifier le type.                                 | `{{5 == "5"}}` → `true`   |
| `===` (Strictement égal)      | Compare les valeurs et le type de données.                                 | `{{5 === "5"}}` → `false` |
| `!=` (Différent)              | Compare si les valeurs sont différentes.                                   | `{{5 != "5"}}` → `false`  |
| `!==` (Strictement différent) | Compare si les valeurs et les types sont différents.                       | `{{5 !== "5"}}` → `true`  |
| `>` (Supérieur à)             | Renvoie `true` si la première valeur est supérieure à la seconde.          | `{{10 > 5}}` → `true`     |
| `<` (Inférieur à)             | Renvoie `true` si la première valeur est inférieure à la seconde.          | `{{3 < 7}}` → `true`      |
| `>=` (Supérieur ou égal)      | Renvoie `true` si la première valeur est supérieure ou égale à la seconde. | `{{8 >= 8}}` → `true`     |
| `<=` (Inférieur ou égal)      | Renvoie `true` si la première valeur est inférieure ou égale à la seconde. | `{{6 <= 5}}` → `false`    |

***

#### 🔄 **Opérateurs de chaînes**

| Opérateur           | Signification           | Exemple                                              |
| ------------------- | ----------------------- | ---------------------------------------------------- |
| `+` (Concaténation) | Concatène deux chaînes. | `{{"Bonjour, " + "monde !"}}` → `"Bonjour, monde !"` |

***

#### 🔀 **Opérateurs de tableaux**

| Opérateur     | Signification                                 | Exemple                                    |
| ------------- | --------------------------------------------- | ------------------------------------------ |
| `.length`     | Renvoie la taille d'un tableau.               | `{{$data?.nomes.length}}`                  |
| `.includes()` | Vérifie si une valeur existe dans le tableau. | `{{$data?.cidades.includes("São Paulo")}}` |
| `.map()`      | Itère sur les éléments et modifie le tableau. | `{{$data?.numeros.map(n => n * 2)}}`       |
| `.filter()`   | Filtre les éléments du tableau.               | `{{$data?.numeros.filter(n => n > 5)}}`    |

### 🔍 **Comment utiliser les conditions IF/ELSE**

Dans Hablla, vous pouvez créer **des règles conditionnelles** dans les flux. Voyez comment cela fonctionne :

#### ✅ **Exemple 1 : Vérifier si un client est qualifié**

```plaintext
{{$data?.lead?.score > 50 ? "Lead qualifié" : "Lead non qualifié"}}
```

Si le score du lead est **supérieur à 50**, le résultat sera `"Lead qualifié"`, sinon, `"Lead non qualifié"`.

#### ✅ **Exemple 2 : Définir un statut par défaut**

```plaintext
{{$data?.pedido?.status ?? "En cours de traitement"}}
```

Si le statut de la commande existe, il sera utilisé. Sinon, le statut par défaut `"En cours de traitement"` sera appliqué.

#### ✅ **Exemple 3 : Combiner plusieurs conditions**

```plaintext
{{$data?.usuario?.idade >= 18 ? "Majeur" : $data?.usuario?.idade > 0 ? "Mineur" : "Âge non renseigné"}}
```

🔹 Si l'âge est supérieur ou égal à **18**, le résultat sera `"Majeur"`.\
🔹 Si l'âge est supérieur à **0**, mais inférieur à **18**, le résultat sera `"Mineur"`.\
🔹 Si l'âge n'est pas renseigné, le résultat sera `"Âge non renseigné"`.

***

### 🎯 **Comment utiliser ces expressions dans la configuration d'un composant**

Chaque fois que vous configurez un composant dans Hablla, vous pouvez utiliser ces expressions dans les champs où vous souhaitez insérer des valeurs dynamiques.

📌 **Exemple pratique :**\
Supposons que nous créons une nouvelle carte dans le flux et que nous voulons y associer une personne identifiée dans un composant précédent. Nous pouvons procéder ainsi :

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

Cela garantit que, si un composant ne trouve pas la personne, l'autre sera utilisé automatiquement.

## Bonnes pratiques dans l'utilisation des variables

Lors de l'utilisation de variables dans des flux d'automatisation, il est important de comprendre la différence entre **des identifiants uniques** et **des attributs descriptifs**.

Certains champs représentent des caractéristiques d'une entité et peuvent être modifiés au fil du temps, comme :

```
name
std_name
status
description
```

D'autres champs existent spécifiquement pour identifier une entité de manière unique, comme :

```
id
```

### Préférez `id` pour des références permanentes

Chaque fois qu'une automatisation doit identifier une entité spécifique — par exemple, une étiquette, une personne, une liste, un secteur, une carte ou un autre objet — préférez utiliser le champ `id`.

Exemple :

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

Le `id` est la référence la plus appropriée pour des automatisations qui doivent rester stables au fil du temps.

Cela évite que des modifications de données affectent la logique du flux.

### Utilisez des attributs descriptifs pour comparer des valeurs

Des champs comme `name` et `std_name` peuvent être utilisés normalement lorsque l'objectif de l'automatisation est d'évaluer le contenu actuel d'une propriété.

Exemple :

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

ou :

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

Dans ce cas, l'automatisation compare délibérément la valeur de cet attribut.

La différence réside dans l'objectif de la condition :

* pour identifier une entité spécifique, utilisez `id`;
* pour évaluer une caractéristique de l'entité, utilisez l'attribut correspondant.

### Pourquoi est-ce important ?

Les attributs descriptifs peuvent changer au cours du cycle de vie de l'entité.

Par exemple, un nom peut être modifié ultérieurement sans que l'objet cesse d'être le même.

L'identifiant continue de représenter la même entité :

```
id = entité spécifique
name = caractéristique actuelle de l'entité
std_name = représentation normalisée du nom
```

Par conséquent, une automatisation construite sur la base du `id` tend à être plus résiliente aux changements futurs.

### Exemple générique

Considérez une entité avec les données suivantes :

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

Pour identifier définitivement cette entité :

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

Pour vérifier si le nom actuel est `"Client VIP"`:

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

Ce sont deux usages différents.

Le premier identifie l'objet.

Le second compare une propriété de l'objet.

### Règle recommandée

Pour construire des automatisations plus robustes :

```
Identification d'entité → utilisez id
Comparaison d'attributs → utilisez l'attribut correspondant
```

Chaque fois qu'il y a un `id` disponible et que l'intention est de faire référence à une entité spécifique, il doit être l'option privilégiée.

> **Bonne pratique :** chaque fois que vous devez créer une référence permanente à une entité dans une automatisation, préférez utiliser le champ `id`. Des champs comme `name` et `std_name` doivent être utilisés lorsque l'intention est de comparer leurs valeurs actuelles.

***

### 🔥 **Résumé : Comment utiliser les variables et expressions dans Hablla**

✅ **Utilisez `{{$data?.codigoDoComponente?.caminhoVariavel}}`** pour accéder aux données des composants précédents.\
✅ **Utilisez `??` pour définir une valeur alternative si la première est nulle ou indéfinie.**\
✅ **Utilisez `||` pour définir une valeur alternative si la première est fausse.**\
✅ **Utilisez `:` pour créer des règles `if/else` dans les champs.**\
✅ **Utilisez `&&` pour définir une valeur uniquement si la condition est vraie.**

🚀 **Avec ces techniques, vous pouvez créer des flux intelligents et personnalisés sans avoir à programmer!**


---

# 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/french/flux-dautomatisations/utilisation-des-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.