Variables et flux de données

Comment les données circulent entre les nœuds via la sortie et les variables des nœuds, avec des règles d'étendue pour les sous-flux et les branches.

De quoi il s'agit

Les nœuds dans Flux ne partagent pas automatiquement les données. Lorsqu'un nœud produit une sortie, comme une réponse HTTP ou une valeur calculée, les nœuds en aval accèdent explicitement à cette sortie par le biais d'expressions. Les variables et le flux de données sont la façon dont vous reliez les données entre les nœuds et les valeurs persistantes tout au long de votre processus.

Il existe deux façons dont les données sont déplacées dans un processus:

• Sortie de nœud : chaque nœud produit une sortie que les nœuds en aval peuvent référencer
• Variables : variables au niveau du processus que vous définissez pour stocker et transmettre des valeurs entre les nœuds

Pour connaître la grammaire des expressions complète, les opérateurs et comment écrire les références $vars , consultez Syntaxe des expressions.

Mode de fonctionnement

Sortie de nœud

Chaque nœud qui produit des données les rend disponibles via $vars.<nodeName>.output. Le nom du nœud est attribué automatiquement en fonction du type de nœud. Par exemple, le premier nœud de requête HTTP se nomme httpRequest1, le second httpRequest2.

Vous pouvez voir le nom de la variable d'un nœud dans le panneau Propriétés lorsque le nœud est sélectionné.

// Access HTTP Request response
$vars.httpRequest1.output.body
$vars.httpRequest1.output.statusCode

// Access Script return value
$vars.script1.output

// Access a second HTTP Request
$vars.httpRequest2.output.body

La structure de sortie dépend du type de nœud. Reportez-vous à la page de référence de chaque nœud pour connaître sa forme de sortie spécifique.

Variables

Les variables sont des valeurs au niveau du processus qui sont conservées pendant la durée d'une exécution unique. Vous les définissez dans le panneau Variables.

Chaque variable a:

• Nom — comment vous le référencez dans les expressions (par exemple, $vars.orderTotal)
• Type — Chaîne, Nombre, Booléen, Objet ou Tableau

Les variables au niveau du processus sont toujours bidirectionnelles - n'importe quel nœud peut les lire ou les écrire. Il n’y a aucun paramètre de direction à configurer. Une valeur en lecture seule ou en écriture seule provient plutôt d'une entrée de déclencheur ou d'une variable de sortie, comme décrit ci-dessous.

Le flux sépare ces trois types de données selon l'endroit où vous les définissez:

Type	Défini dans	Direction	Syntaxe de référence
Variable	Module Variables	Bidirectionnel (lecture et écriture)	$vars.<name>
EntréeDéclencheur	Sur le nœud du déclencheur	Lecture seule	$vars.<triggerName>.output.<name>
Variable de sortie	Sur un nœud final	Écriture uniquement	$vars.<name>

Quand utiliser des variables ou la sortie du nœud:

• La sortie du nœud correspond aux données qui sont transmises d’un nœud au suivant. Il s'agit du modèle le plus courant.
• Les variables correspondent à des valeurs qui doivent être accessibles sur l’ensemble du processus.
• Les entrées et les sorties correspondent à des valeurs qui définissent ce que le processus reçoit ou renvoie - voir Entrées du déclencheur et Variables de sortie ci-dessous.

Nommer clairement les variables: des noms descriptifs en minuscules avec des traits d’union ou camelCase — tels que customerEmail, invoiceTotal, apiResponse — restent lisibles dans les traces d’exécution au fil du temps. Les noms et les abréviations à lettre unique perdent rapidement leur signification.

Entrées du déclencheur

Les variables d'entrée ne sont pas définies dans la section Variables - elles sont ajoutées directement sur les entrées d'un nœud de déclencheur, ce qui les rend en lecture seule. Lorsqu'un déclencheur se déclenche, ses entrées sont disponibles sous la forme $vars.<triggerName>.output.<inputName>:

// Access an input defined on a Manual Trigger named "manualTrigger1"
$vars.manualTrigger1.output.userId

Cela s'applique à tous les types de déclencheurs. Si votre processus comporte plusieurs déclencheurs, chaque déclencheur possède ses propres entrées - les nœuds en aval font référence au déclencheur spécifique qui a démarré l'exécution.

Variables de sortie

Les variables de sortie représentent le résultat du processus. Vous les ajoutez directement sur un nœud final, et non dans le panneau Variables, ce qui les rend en écriture seule.

// Access an output variable named "finalStatus"
$vars.finalStatus

Chaque variable de sortie a:

• Nom — comment vous le référencez dans les expressions (par exemple, $vars.finalStatus)
• Type de données — Chaîne, Nombre, Booléen, Objet ou Tableau
• Description — une note facultative sur ce que la valeur représente
• Valeur par défaut — une solution de secours facultative utilisée lorsque rien ne définit la variable

La valeur d'une variable de sortie est définie de la même manière que toute autre variable, à partir de la section Mettre à jour la variable d'un nœud ou de la valeur de retour d'un nœud de script.

Définitions des variables

Les définitions de variables sont définies dans le panneau Variables. Chaque définition stocke le nom et le type de la variable afin que la valeur puisse être référencée de manière cohérente pendant une exécution.

Mises à jour des variables

Les variables peuvent être mises à jour par la configuration du nœud ou par la sortie du nœud de script.

Depuis n'importe quel nœud - Section Mettre à jour la variable

Chaque nœud dispose d'une section Mettre à jour la variable dans le panneau Propriétés. La section stocke une cible de variable inscriptible — une variable de processus ou une variable de sortie — et l'expression JavaScript qui lui est affectée. L'expression est évaluée une fois le nœud terminé.

À partir d'un nœud de script — valeur renvoyée

La valeur de retour d'un nœud de script est accessible en aval sous la forme $vars.<scriptName>.output. Le nœud Script dispose également de la même section Mettre à jour la variable que les autres nœuds pour les écritures directes de variables:

// The return value becomes $vars.script1.output
return {
  orderTotal: $vars.httpRequest1.output.body.price * $vars.httpRequest1.output.body.quantity
};

Règles d’étendue

Un nœud peut accéder à la sortie de:

• Nœuds en amont dans la même étendue — nœuds au même niveau qui s'exécutait avant
• Nœuds de conteneur parent : si le nœud se trouve dans un sous-flux ou une boucle, il peut accéder à l'étendue du parent

Un nœud ne peut pas accéder à la sortie de:

• Nœuds dans une branche différente — si une exécution Décision ou Basculer envoie un chemin différent, la sortie de ces nœuds n'est pas disponible
• Nœuds qui n'ont pas été exécutés — la sortie n'existe qu'après l'exécution d'un nœud

Étendue du sous-flux

Les sous-flux créent leur propre étendue de variables. Les nœuds à l'intérieur d'un sous-flux peuvent accéder:

• Autres nœuds au sein du même sous-flux
• L’étendue du processus parent

Les variables mises à jour à l'intérieur d'un sous-flux sont placées dans l'espace de noms pour éviter les conflits avec le processus parent. Par exemple, une variable counter à l'intérieur d'un sous-flux nommé subflow1 est référencée comme $vars.subflow1.counter depuis l'extérieur du sous-flux.

La valeur de retour du sous-flux est accessible au processus parent sous la forme $vars.<subflowName>.output.

Branches parallèles

Les branches parallèles ont des contextes d'exécution indépendants. La confusion d'une variable dans une branche ne rend pas cette modification visible dans une autre branche. Un nœud de fusion consolide les sorties de chemins parallèles lorsque les chemins doivent se joindre.

Modèles

Création de chaînes dynamiques

Les littéraux de modèle dans un nœud de script combinent des variables et du texte statique:

return `Hello ${firstName}, your order #${orderId} has shipped.`;

Cumul de valeurs dans une boucle

Un modèle d'accumulateur utilise un tableau initialisé avant le nœud de boucle et ajouté à l'intérieur du corps de la boucle:

// Script node inside the Loop body
results.push(item.processedValue);
return results;

Garder les valeurs secrètes en dehors des journaux

Les valeurs des variables secrètes sont masquées dans l’interface utilisateur, mais peuvent apparaître dans les données de traçage exportées. Leur journalisation présente un risque d’exposition des données.

Exemple pratique

Un processus qui récupère un utilisateur à partir d'une API et le route en fonction de son rôle:

Étape 1 — Requête HTTP (httpRequest1): GET https://api.example.com/users/42

Étape 2 — Script (script1): extraire le rôle de l'utilisateur

const user = $vars.httpRequest1.output.body;
return {
  name: user.name,
  role: user.role,
  isAdmin: user.role === "admin"
};

Étape 3 — Décision (decision1): branche sur le statut d'administrateur

Expression: $vars.script1.output.isAdmin === true

• Vrai → accorder l'accès administrateur
• Faux → accorder un accès standard

Pages liées

• Syntaxe des expressions — $vars grammaire, opérateurs, où vous écrivez des expressions, erreurs courantes
• Nœud de script — écriture JavaScript, valeurs renvoyées, accès $vars
• Nœud de décision — ramification sur les expressions
• Le panneau Propriétés de la zone de dessin , panneau Variables