Encore un problème de boucle - 2 000 éléments en... 21 000 éléments en sortie

Décrivez le problème/l’erreur/la question

J’ai une boucle dans une boucle. Mon workflow crée 2 000 éléments et la taille de lot de la boucle externe est 100. La boucle interne a une taille de lot de 1. Le premier lot de la boucle externe est traité comme prévu, mais la deuxième boucle se comporte très étrangement. À la fin, j’obtiens 21 000 éléments en sortie de la boucle externe. Qu’est-ce qui ne va pas ou s’agit-il d’un bug ?

Quel est le message d’erreur (le cas échéant) ?

Veuillez partager votre workflow

Partagez la sortie renvoyée par le dernier nœud

Informations sur votre configuration n8n

  • Version n8n : 2.23.2 Community Edition
  • Base de données (par défaut : SQLite) :
  • Paramètre EXECUTIONS_PROCESS de n8n (par défaut : own, main) :
  • Exécution de n8n via (Docker, npm, n8n cloud, application de bureau) :
  • Système d’exploitation : Ubuntu 22.04
  1. Déconnectez la connexion qui revient de Outer Loop vers Outer Loop Over Items.
  2. Placez un nœud Code immédiatement après la fin de votre boucle interne (sur la branche « Done »), juste avant qu’elle ne reboucle vers la boucle externe.
  3. Utilisez ce nœud de code pour faire passer les données, mais configurez la boucle interne pour qu’elle se réinitialise. Dans les versions plus récentes du nœud Split In Batches / Looping, vous pouvez basculer l’option Reset sur true.
    J’espère que cela vous aidera

Salut @Nadir

Le problème est que les « câbles » de votre workflow sont connectés aux mauvais ports. Dans n8n, le nœud Split in Batches dispose de deux sorties : une pour les éléments actuellement traités (la Loop) et une pour quand tout est terminé (le Done path). Vous avez accidentellement échangé ces deux sorties, ce qui signifie que votre workflow essaie de commencer l’étape suivante uniquement après que tout soit déjà terminé, et il crée des boucles de retour qui ne devraient pas exister.

Du fait de ces connexions échangées, vous avez créé une « boucle de rétroaction ». Au lieu de traiter chaque élément une seule fois, le workflow déclenche de nouveaux cycles de la boucle chaque fois qu’un lot se termine. Cela provoque une multiplication exponentielle des éléments, ce qui explique pourquoi vos 2 000 éléments initiaux se sont transformés en 21 000.

Pour corriger cela, assurez-vous que la sortie supérieure (Loop) de la Outer Loop va dans la Inner Loop, et que la sortie supérieure de la Inner Loop gère votre travail réel. La sortie inférieure (Done) de la Inner Loop devrait alors pointer vers la Outer Loop pour demander le lot suivant. Cela garantit que la boucle interne termine tous ses éléments avant que la boucle externe n’avance.

Essayez ceci

Salut ! Merci d’avoir pris le temps de regarder ça.

Mon workflow selon vos conseils - est-ce que j’ai mal compris quelque chose ? :

Si j’active l’option de réinitialisation sur la Boucle Interne sur les Éléments, je me retrouve dans une boucle infinie. Je ne peux m’en sortir qu’en redémarrant le système N8N.

{
"nodes": [
{
"parameters": {},
"type": "n8n-nodes-base.manualTrigger",
"typeVersion": 1,
"position": [
-144,
-64
],
"id": "dded6d9b-9f8d-4227-8fc5-12159d18723b",
"name": "Lors du clic sur 'Exécuter le workflow'"
},
{
"parameters": {},
"type": "n8n-nodes-base.wait",
"typeVersion": 1.1,
"position": [
912,
-64
],
"id": "6bcb6624-8761-4f94-879c-2dc3cfb6fe7b",
"name": "Attendre",
"webhookId": "f3fe0b63-6c82-49eb-8380-d60c3f1541c6"
},
{
"parameters": {},
"type": "n8n-nodes-base.noOp",
"typeVersion": 1,
"position": [
672,
96
],
"id": "d7112c4a-6db2-4a14-98d1-f5c218502e8a",
"name": "Boucle interne"
},
{
"parameters": {},
"type": "n8n-nodes-base.noOp",
"typeVersion": 1,
"position": [
1120,
128
],
"id": "08aed799-7b15-4f38-be6e-35f74f432366",
"name": "Boucle externe"
},
{
"parameters": {
"options": {
"reset": true
}
},
"type": "n8n-nodes-base.splitInBatches",
"typeVersion": 3,
"position": [
448,
32
],
"id": "acf6c806-01e4-4b38-8aac-14f488408e89",
"name": "Boucle Interne sur les Éléments"
},
{
"parameters": {
"batchSize": 100,
"options": {}
},
"type": "n8n-nodes-base.splitInBatches",
"typeVersion": 3,
"position": [
240,
-32
],
"id": "05ed47b8-8ecc-4313-8702-e3cf2ddb1adb",
"name": "Boucle Externe sur les Éléments"
},
{
"parameters": {
"jsCode": "const items = ;\n\nfor(let i = 1; i <= 2000; i++) {\n items.push({\n json: {\n id: i,\n }\n })\n}\n\nreturn items;"
},
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [
32,
-64
],
"id": "8af1c78b-59a6-42df-a269-2f3c36dbcc5a",
"name": "Créer les Éléments"
},
{
"parameters": {
"jsCode": "// Parcourir les éléments d'entrée et ajouter un nouveau champ appelé 'myNewField' au JSON de chacun\nfor (const item of $input.all()) {\n item.json.myNewField = 1;\n}\n\nreturn $input.all();"
},
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [
672,
-64
],
"id": "7676d152-fae2-4a54-94ef-4b3c685b1ed6",
"name": "Code en JavaScript"
}
],
"connections": {
"Lors du clic sur 'Exécuter le workflow'": {
"main": [
[
{
"node": "Créer les Éléments",
"type": "main",
"index": 0
}
]
]
},
"Attendre": {
"main": [
[
{
"node": "Boucle externe",
"type": "main",
"index": 0
}
]
]
},
"Boucle interne": {
"main": [
[
{
"node": "Boucle Interne sur les Éléments",
"type": "main",
"index": 0
}
]
]
},
"Boucle externe": {
"main": [
[
{
"node": "Boucle Externe sur les Éléments",
"type": "main",
"index": 0
}
]
]
},
"Boucle Interne sur les Éléments": {
"main": [
[
{
"node": "Code en JavaScript",
"type": "main",
"index": 0
}
],
[
{
"node": "Boucle interne",
"type": "main",
"index": 0
}
]
]
},
"Boucle Externe sur les Éléments": {
"main": [
[ ], [ { “node”: “Boucle Interne sur les Éléments”, “type”: “main”, “index”: 0 } ] ] }, “Créer les Éléments”: { “main”: [ [ { “node”: “Boucle Externe sur les Éléments”, “type”: “main”, “index”: 0 } ] ] }, “Code en JavaScript”: { “main”: [ [ { “node”: “Attendre”, “type”: “main”, “index”: 0 } ] ] } }, “pinData”: {}, “meta”: { “instanceId”: “3a5f2016f235f0058559dcaa60a889f9bd210e06a6a8d1adec8c4d5747d8d207” } }`

Je suis extrêmement désolé, vous pouvez utiliser la solution proposée par kjooleng ou j’ai une autre solution qui consiste à créer un autre workflow.
Créer un deuxième workflow :

  • Commencez par un Execute Workflow Trigger.

  • Connectez-le à votre Split In Batches (Batch size: 1).

  • Mettez votre logique de Inner loop à l’intérieur.

  • Quand ce workflow se termine, il détruit naturellement son état, ce qui signifie qu’il est parfaitement frais à chaque fois qu’il est appelé.

  1. Modifiez votre workflow principal (The Outer Loop) :
    • Gardez votre Outer Loop Over Items (Batch size: 100).

    • À l’intérieur de la boucle externe, à la place de vos anciens nœuds de boucle interne, utilisez un nœud Execute Workflow qui appelle votre deuxième workflow.

    • Passez-lui le lot actuel de 100 éléments.

Ça ne fonctionne pas du tout. La boucle externe transférera le premier lot via la sortie de la boucle vers le nœud Outer Loop, et comme il n’y a aucun moyen de revenir à la boucle externe via Items, rien ne se passe. La boucle interne ne sera jamais atteinte par cette configuration.

Peut-être que je devrais expliquer pourquoi j’ai besoin de cette configuration. J’ai plus de 20 000 articles et dois les envoyer via une requête HTTP à une API externe. Cette API externe ne peut traiter que 999 articles maximum par appel. Je dois donc traiter les 20 000 articles par lots. La boucle interne doit traduire les articles (999 maximum) dans le bon format et appeler l’API.

@SE-automations Je n’aime pas ça, mais je vais essayer avec un sous-workflow.

Bonjour @Nadir

Peut-être est-ce ce que vous cherchez

@kjooleng La requête HTTP retourne un document XML contenant 999 éléments. Après la requête HTTP, je transforme le XML en JSON avec 999 éléments. Et maintenant, j’ai besoin que la boucle interne boucle sur ces 999 éléments avant de traiter le lot suivant (les 999 éléments suivants). Fondamentalement, j’ai besoin d’analyser le résultat de la requête HTTP avant de déclencher la prochaine requête HTTP. C’est pourquoi j’ai besoin de la boucle interne comme faisant partie de la boucle externe. Je vais essayer avec le sous-workflow.

Cependant - je pense que c’est un bug dans le nœud Loop.

Placer la boucle interne dans son propre workflow et l’appeler à partir de la boucle externe fonctionne bien.

Content que tu aies trouvé la solution :smiley:

En regardant votre workflow, le problème est évident. La sortie de votre boucle interne se reconnecte au nœud de la boucle externe, ce qui signifie que chaque fois que la boucle interne termine un lot, elle réinjecte ses résultats dans le flux d’éléments de la boucle externe. C’est exactement pourquoi vous vous retrouvez avec 21 000 éléments au lieu de 2 000.

La connexion de la boucle interne vers le nœud Boucle externe sur les éléments ne devrait pas être là. La seule chose qui devrait réalimenter le nœud Boucle externe sur les éléments est la connexion de boucle elle-même, pas la sortie traitée.

Voici comment corriger cela :

Supprimez la connexion allant de la sortie de la boucle interne vers le nœud Boucle externe sur les éléments.

Le nœud de sortie de la boucle externe devrait être votre sortie finale, tout ce qui en sort est votre résultat final après le traitement de tous les lots.

Si vous avez besoin de collecter tous les résultats à la fin, ajoutez un nœud Fusionner après la sortie de la boucle externe pour consolider le tout proprement.

Essentiellement, votre boucle externe devrait piloter les lots, la boucle interne devrait traiter chaque élément dans ce lot, et les résultats devraient avancer vers la sortie de la boucle externe, et non reboucler vers le début de la boucle externe à nouveau.

Corrigez cette connexion et votre nombre d’éléments devrait être exactement correct.

@akingbade-Samuel Salut ! Je ne comprends pas ce que tu veux dire. La seule boucle qui revient à la Outer Loop Over Items provient de la Inner Loop Over Items done output.

La multiplication des éléments se produit parce que la boucle interne « Loop Over Items » accumule les éléments à travers ses lots en interne, et quand sa sortie « Done » se déclenche, n8n transmet tous les éléments accumulés à l’entrée de la boucle externe. Chaque itération de lot externe transporte alors un nombre croissant d’éléments provenant des exécutions précédentes.

La solution : sur votre nœud « Loop Over Items » interne, activez l’option « Reset ». Cela réinitialise le compteur interne de la boucle interne à chaque fois qu’elle est appelée par la boucle externe, de sorte que chaque lot externe recommence à zéro avec uniquement ses propres éléments, et non le total cumulé de tous les lots précédents.

Si l’option Reset est déjà activée et le problème persiste, partagez une capture d’écran des paramètres des deux nœuds de boucle — cela aidera à réduire le champ des possibilités.

Comme je l’ai mentionné ci-dessus, si j’active la réinitialisation dans la boucle interne, je me retrouve dans une boucle interne infinie qui ne peut être arrêtée qu’en redémarrant le serveur. La solution avec le sous-flux fonctionne et c’est essentiellement le même câblage. Le sous-flux retourne également 100 éléments et ceux-ci ne sont pas ajoutés à la boucle externe.

@nguyenthieutoan Les paramètres sont visibles dans le flux de travail téléchargé. Il suffit de double-cliquer sur le nœud.

Hé ! Ce n’est pas un bug, c’est une particularité connue des boucles imbriquées dans n8n.

Le problème : Quand votre boucle interne se termine, elle repasse ses éléments à la boucle externe à chaque itération. Au lieu que la boucle externe passe simplement au lot suivant, elle accumule tous les éléments des exécutions de la boucle interne, c’est pour ça que vous vous retrouvez avec 21 000 au lieu de 2 000.

La solution : Ajoutez un nœud Summarize ou un nœud Code juste avant que la boucle interne se renvoie à la boucle externe pour réinitialiser/effacer le nombre d’éléments. Fondamentalement, vous devez vous assurer que seuls les éléments attendus sont renvoyés vers le haut.

Vérifiez aussi deux fois que la sortie « done » de votre boucle interne est connectée correctement — elle ne doit se connecter qu’en avant, et ne doit pas accidentellement se renvoyer à l’entrée de la boucle externe.

@Ayomikun27 Si j’utilise un sous-flux de travail à la place de la boucle interne, ce sous-flux de travail me renverra également 100 éléments. Mais ces 100 éléments ne sont pas ajoutés à la boucle externe. Il doit donc y avoir un bug.

{
“nodes”: [
{
“parameters”: {
“batchSize”: 999,
“options”: {}
},
“type”: “n8n-nodes-base.splitInBatches”,
“typeVersion”: 3,
“position”: [
3536,
1088
],
“id”: “1796ac9c-4527-4682-b7ce-be15fb995083”,
“name”: “Get 999 items at a time”
},
{
“parameters”: {
“url”: "your api ",
“options”: {}
},
“type”: “n8n-nodes-base.httpRequest”,
“typeVersion”: 4.4,
“position”: [
3760,
1168
],
“id”: “92c992a3-c11c-45d7-a24e-f3ab21507c26”,
“name”: “send HTTP req with 999 items”
},
{
“parameters”: {
“options”: {
“reset”: “={{ $prevNode.name ===‘send HTTP req with 999 items’}}”
}
},
“type”: “n8n-nodes-base.splitInBatches”,
“typeVersion”: 3,
“position”: [
3952,
1200
],
“id”: “81b34dbd-a826-4561-ad84-812a634dddfa”,
“name”: “loop over those 999 item’s response”
},
{
“parameters”: {},
“type”: “n8n-nodes-base.noOp”,
“typeVersion”: 1,
“position”: [
4176,
1296
],
“id”: “9c9bb1f7-0417-4fa1-b0b3-ce0e474e3d32”,
“name”: “Do your operation with them”
},
{
“parameters”: {
“jsCode”: “const items = ;\n\nfor(let i = 1; i <= 2000; i++) {\n items.push({\n json: {\n id: i,\n }\n })\n}\n\nreturn items;”
},
“type”: “n8n-nodes-base.code”,
“typeVersion”: 2,
“position”: [
3328,
1056
],
“id”: “3a6ef3b8-3c88-48ab-b64f-bcc20b17990b”,
“name”: “Get your data”
},
{
“parameters”: {
“options”: {}
},
“type”: “n8n-nodes-base.set”,
“typeVersion”: 3.4,
“position”: [
3744,
992
],
“id”: “21223cf6-52b9-430c-951b-84a1e2471274”,
“name”: “Done”
}
],
“connections”: {
“Get 999 items at a time”: {
“main”: [
[
{
“node”: “Done”,
“type”: “main”,
“index”: 0
}
],
[
{
“node”: “send HTTP req with 999 items”,
“type”: “main”,
“index”: 0
}
]
]
},
“send HTTP req with 999 items”: {
“main”: [
[
{
“node”: “loop over those 999 item’s response”,
“type”: “main”,
“index”: 0
}
]
]
},
“loop over those 999 item’s response”: {
“main”: [
[
{
“node”: “Get 999 items at a time”,
“type”: “main”,
“index”: 0
}
],
[
{
“node”: “Do your operation with them”,
“type”: “main”,
“index”: 0
}
]
]
},
“Do your operation with them”: {
“main”: [
[
{
“node”: “loop over those 999 item’s response”,
“type”: “main”,
“index”: 0
}
]
]
},
“Get your data”: {
“main”: [
[
{
“node”: “Get 999 items at a time”,
“type”: “main”,
“index”: 0
}
]
]
}
},
“pinData”: {},
“meta”: {
“instanceId”: “0f39d8fdd402ddce20d0eb724526828e8c2d8679170e3a08fe6cd471c799fab6”
}
}

Essayez ceci. Utilisez simplement le mode « expression » avec cette instruction dans votre boucle interne. Faites-moi savoir si cela fonctionne.

Le chiffre 21 000 est la clé. C’est 100+200+300…+2000, un nombre triangulaire. Ce qui se passe, c’est qu’à chaque fois que votre boucle interne se termine et réalimente la boucle externe, n8n accumule tous les éléments précédemment vus au lieu de simplement traiter le lot actuel. À la 20e itération externe, vous transportez 2 000 éléments à travers celle-ci.

C’est un comportement connu avec les nœuds SplitInBatches imbriqués — ils partagent l’état d’exécution d’une manière qui cause l’accumulation des éléments.

La solution : déplacez votre boucle interne vers un flux de travail séparé et appelez-le avec le nœud Execute Workflow. Passez chaque lot externe en entrée, exécutez la boucle interne là-bas, renvoyez les résultats. Cela isole complètement les deux états de boucle.

Flux de travail externe : SplitInBatches (100) > Execute Workflow
Flux de travail interne : reçoit les 100 éléments, exécute SplitInBatches (1) sur eux, renvoie les résultats

C’est un peu plus de configuration, mais c’est le modèle fiable pour les boucles imbriquées dans n8n.