> ## Documentation Index
> Fetch the complete documentation index at: https://docs.twenty.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Utiliser l'itérateur

> Parcourez des tableaux d'enregistrements pour exécuter des actions sur chaque élément.

L'itérateur vous permet de parcourir un tableau d'enregistrements et d'exécuter des actions sur chacun. Il est essentiel pour les workflows qui doivent traiter plusieurs enregistrements renvoyés par Rechercher des enregistrements ou reçus via des webhooks.

## Quand utiliser l'itérateur

| Scénario                               | Exemple                                                            |
| -------------------------------------- | ------------------------------------------------------------------ |
| **Traiter les résultats de recherche** | Envoyer un e-mail à chaque personne trouvée                        |
| **Gérer les tableaux de webhooks**     | Créer des enregistrements pour chaque élément, dans l'ordre        |
| **Mises à jour en masse**              | Mettre à jour plusieurs enregistrements avec des valeurs calculées |
| **Notifications**                      | Avertir plusieurs personnes d'un événement                         |

## Comprendre l'itérateur

L'itérateur attend un **tableau** en entrée. Il va ensuite :

1. Prend le premier élément du tableau
2. Exécute toutes les actions à l'intérieur de l'itérateur avec cet élément
3. Passe à l'élément suivant
4. Répète jusqu'à ce que tous les éléments soient traités

### Sélection du tableau à parcourir

La plupart des sources de tableaux (Search Records, un champ de tableau de webhook, un déclencheur manuel Bulk) peuvent être sélectionnées directement dans le sélecteur de variables.

Lorsqu’une étape **Code** ou **Logic Function** renvoie un *tableau de premier niveau*, sa sortie apparaît dans le sélecteur de variables sous forme d’entrées indexées (`0`, `1`, `2`, …). Pour effectuer une boucle sur le tableau dans son ensemble, sélectionnez l’option **Whole list** pour cette étape — l’Iterator en déduit alors automatiquement la structure de chaque élément à partir de la liste.

## Configuration de base

### Exemple : envoyer un e-mail à toutes les personnes dans les résultats de recherche

**Objectif** : Trouver tous les contacts d'une entreprise spécifique et envoyer à chacun un e-mail personnalisé.

### Étape 1 : Rechercher des enregistrements

1. Ajoutez l'action **Rechercher des enregistrements**
2. Objet : **Personnes**
3. Filtre : Entreprise égale à "Acme Inc"
4. Cela renvoie un tableau de personnes

### Étape 2 : Vérifier que des résultats existent

1. Ajoutez l'action **Filtre**
2. Condition : `{{searchRecords.length}}` est supérieur à 0
3. Cela évite les erreurs de l'itérateur sur des résultats vides

### Étape 3 : Ajouter un itérateur

1. Ajoutez une action **Itérateur**
2. Entrée du tableau : sélectionnez `{{searchRecords}}`
3. Cela crée une boucle

### Étape 4 : Ajouter des actions dans l'itérateur

Les actions placées dans l'itérateur s'exécutent pour chaque élément :

1. Ajoutez une action **Envoyer un e-mail** (dans l'itérateur)
2. À : `{{iterator.currentItem.email}}`
3. Objet : Bonjour `{{iterator.currentItem.firstName}}` !
4. Corps : Message personnalisé utilisant les champs de l'élément en cours

### Résultat

Si l'action Rechercher des enregistrements renvoie 5 personnes, l'itérateur :

* Envoie un e-mail à la personne 1
* Envoie un e-mail à la personne 2
* ... continue pour les 5

## Accéder aux données de l'élément en cours

Dans l'itérateur, utilisez `{{iterator.currentItem}}` pour accéder à l'enregistrement en cours :

| Variable                                | Description                                               |
| --------------------------------------- | --------------------------------------------------------- |
| `{{iterator.currentItem}}`              | L'objet de l'enregistrement en cours dans son intégralité |
| `{{iterator.currentItem.id}}`           | ID de l'enregistrement                                    |
| `{{iterator.currentItem.email}}`        | Champ e-mail                                              |
| `{{iterator.currentItem.company.name}}` | Nom de l'entreprise associée                              |
| `{{iterator.index}}`                    | Position actuelle dans le tableau (indexé à partir de 0)  |

Dans le sélecteur de variables, vous pouvez soit explorer un champ spécifique de l’élément courant, soit choisir **Use the whole item** pour référencer l’intégralité de l’élément courant (`{{iterator.currentItem}}`). Sélectionner l’élément entier est pratique lorsque vous voulez transmettre un enregistrement complet directement à une étape en aval plutôt que de le reconstruire champ par champ.

## Modèles courants

### Mettre à jour plusieurs enregistrements

**Objectif** : Marquer toutes les tâches en retard comme "En retard"

```
1. Search Records (Tasks, Due Date < Today, Status ≠ Completed)
2. Filter (length > 0)
3. Iterator (searchRecords)
   └── Update Record
       - Object: Tasks
       - Record: {{iterator.currentItem.id}}
       - Status: Late
```

### Créer des enregistrements à partir d'un tableau

**Objectif** : Le webhook reçoit une commande avec plusieurs éléments, créer un enregistrement pour chacun

```
1. Webhook Trigger (receives items array)
2. Filter (items.length > 0)
3. Iterator (trigger.body.items)
   └── Create Record
       - Object: Order Items
       - Name: {{iterator.currentItem.name}}
       - Quantity: {{iterator.currentItem.qty}}
       - Related Order: {{trigger.body.orderId}}
```

### Traitement conditionnel dans la boucle

**Objectif** : N'envoyer un e-mail qu'aux contacts avec des adresses valides

```
1. Search Records (People)
2. Iterator (searchRecords)
   └── Filter (currentItem.email is not empty)
       └── Send Email
           - To: {{iterator.currentItem.email}}
```

## Résolution des problèmes

### "L'itérateur attend un tableau"

**Cause** : Vous avez passé un seul enregistrement au lieu d'un tableau.

**Correctif** : Assurez-vous de passer le résultat de Rechercher des enregistrements ou un champ de type tableau, pas un seul enregistrement.

```
✅ Correct: {{searchRecords}}
❌ Wrong: {{searchRecords[0]}}
```

### L'itérateur ne s'exécute pas

**Cause** : Le tableau est vide.

**Correctif** : Ajoutez un filtre avant l'itérateur pour vérifier la longueur du tableau :

```
Filter: {{searchRecords.length}} > 0
```

### Les actions s'exécutent trop de fois

**Cause** : Rechercher des enregistrements a renvoyé plus d'enregistrements que prévu.

**Correctif** :

* Ajoutez des filtres plus spécifiques à Rechercher des enregistrements
* Définissez une limite sur Rechercher des enregistrements (max 200)
* Ajoutez un filtre dans l'itérateur pour des conditions supplémentaires

## Considérations relatives aux performances

* **Utilisation de crédits** : Chaque itération consomme des crédits pour ses actions
* **Temps** : Les grands tableaux prennent plus de temps à traiter
* **Limites** : Envisagez de traiter par lots les opérations très volumineuses
* **Limites de débit** : Les appels d'API externes peuvent atteindre des limites de débit avec de nombreuses itérations

## Meilleures pratiques

1. **Vérifiez toujours la longueur du tableau** avant l'itérateur pour éviter les erreurs
2. **Ajoutez des filtres dans les boucles** quand tous les éléments n'ont pas besoin d'être traités
3. **Renommez votre étape Itérateur** pour décrire ce qu'elle parcourt
4. **Testez avec de petits tableaux** avant de traiter de grands ensembles de données
5. **Surveillez l'exécution des workflows** pour vous assurer que les itérations se terminent comme prévu

## Articles connexes

* [Actions de workflows](/l/fr/user-guide/workflows/capabilities/workflow-actions)
* [Comment utiliser les branches](/l/fr/user-guide/workflows/capabilities/use-branches-in-workflows)
* [FAQ sur les workflows](/l/fr/user-guide/workflows/how-tos/need-more-help/workflows-faq)