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 l'onglet Variables du panneau Propriétés.

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
• Direction — entrée, sortie ou bidirectionnelle

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 ou à des valeurs qui définissent les entrées et les sorties du processus lui-même.

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 appartiennent à leur déclencheur, et non au processus. 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.

Définitions des variables

Les définitions de variables se trouvent dans l'onglet Variables du panneau Propriétés. Chaque définition stocke le nom, le type et la direction 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 (sortie ou direction bidirectionnelle) 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 , onglet Variables