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.

Les nœuds d'un workflow ne partagent pas automatiquement les données. Lorsqu'un nœud produit une sortie, telle qu'une réponse HTTP ou une valeur calculée, les nœuds qui se trouvent après, appelés nœuds en aval, lisent cette sortie via des expressions. Une expression est un court élément de JavaScript qui lit ou calcule une valeur. Le flux de données est la façon dont un workflow transmet des valeurs entre les nœuds et les conserve pendant la durée d’une exécution.

Les données sont déplacées dans un workflow de deux manières:

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

La syntaxe des expressions décrit la grammaire complète, les opérateurs et la façon d’écrire les références $vars .

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 à partir du type de nœud. Par exemple, le premier nœud de requête HTTP est nommé httpRequest1 et le second est nommé httpRequest2.

Le nom de la variable d'un nœud est son ID, affiché dans l'onglet Avancé du panneau Propriétés lorsque le nœud est sélectionné. L'icône en forme de crayon à côté de l'ID le modifie.

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

// 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. Chaque page de la référence de nœud répertorie la sortie de son nœud.

Erreurs de nœud

Lorsqu'un nœud échoue et que sa gestion des erreurs est connectée, les détails de l'échec se trouvent sur $vars.<nodeName>.error, à côté de la sortie du nœud. Lisez-les dans les nœuds sur le chemin d'erreur, par exemple dans un nœud Script qui enregistre l'échec:

// Read the error of a failed HTTP Request
$vars.httpRequest1.error.message   // what went wrong
$vars.httpRequest1.error.status    // the HTTP status, for example 404

The error object exists only on the error path. On the success path, $vars.<nodeName>.error is undefined. The error object lists all its fields.

Variables

Les variables sont des valeurs au niveau du workflow qui sont conservées pendant la durée d'une exécution unique. Vous les définissez dans le panneau Variables , qui s'ouvre à partir de l'onglet Variables à côté de l'onglet Propriétés à droite. Le panneau répertorie les entrées, les sorties et les variables du workflow, ainsi que la sortie de chaque nœud. Un commutateur bascule entre Toutes les variables et Nœud sélectionné. L'icône Se concentrer sur un nœud sur la ligne d'un nœud permet d'effectuer un zoom sur ce nœud. Lorsque le nœud sélectionné est activé, le panneau est limité au nœud sélectionné et son en-tête affiche le nom de cette étendue, par exemple Étendue: Déclencheur manuel.

Le + à côté de Variables dans le panneau ouvre la boîte de dialogue Ajouter une variable . Chaque variable a:

• Nom: comment vous le référencez dans les expressions, par exemple $vars.orderTotal.
• 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 valeur de départ facultative.

Les variables au niveau du workflow 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.

Les trois types de données diffèrent selon l'endroit où vous les définissez:

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

Quand utiliser chacun:

• 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 workflow.
• Les entrées et les sorties correspondent à des valeurs qui définissent ce que le workflow lui-même reçoit ou renvoie, comme décrit dans les sections Entrées du déclencheur et Variables de sortie ci-dessous.

Les noms camelCase descriptifs, tels que customerEmail, invoiceTotal et 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 . Ils sont ajoutés comme arguments d'entrée dans le panneau Propriétés du déclencheur, ou avec le + à côté du déclencheur dans le panneau Variables , ce qui ouvre la boîte de dialogue Ajouter une variable d'entrée . Les deux façons les rendent 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 workflow comporte plusieurs déclencheurs, chaque déclencheur possède ses propres entrées, et 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 workflow. Elles sont ajoutées avec Ajouter une variable de sortie dans l'onglet Paramètres d'un nœud Fin ou avec le + à côté de Sorties dans le panneau Variables . Elles sont 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 valeur 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, depuis la section Mettre à jour la variable d'un nœud ou en tant que 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

Chaque nœud dispose d'une section Mettre à jour la variable dans l'onglet Avancé du panneau Propriétés, où Ajouter une mise à jour de la variable ajoute une affectation. La section stocke une cible de variable inscriptible, qui est une variable de workflow 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

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écutaient avant.
• Nœuds de conteneur parent: si le nœud se trouve à l'intérieur d'un sous-flux ou d'une boucle, il peut accéder à l'étendue du parent.

Étendue fait référence à la partie d’un workflow où un nom peut être lu. Un nœud ne peut pas accéder à la sortie de:

• Nœuds dans une branche différente: si une Décision ou un commutateur envoie l'exécution vers 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 workflow parent

Les variables mises à jour dans un sous-flux sont nommées, c'est-à-dire préfixées avec le nom du sous-flux, pour éviter les conflits avec le workflow 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 workflow parent sous la forme $vars.<subflowName>.output.

Branches parallèles

Chaque branche parallèle a ses propres variables. 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 ${$vars.firstName}, your order #${$vars.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 workflow qui récupère un utilisateur à partir d'une API et le route en fonction de son rôle a trois nœuds:

1. Requête HTTP (httpRequest1): envoie une requête GET à https://api.example.com/users/42.
2. Script (script1): extrait le rôle de l'utilisateur, avec ce code:

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

3. Décision (decision1): branche sur le statut d'administrateur, avec cette expression:

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

La branche Vrai accorde un accès administrateur et la branche Faux accorde un accès standard.

Prochaines étapes

• Syntaxe des expressions: $vars grammaire, opérateurs, où les expressions sont écrites et erreurs courantes.
• Nœud de script: écriture de JavaScript, valeurs renvoyées et accès $vars .
• Nœud de décision: ramification sur les expressions.
• Le canevas Flow: le panneau Propriétés et le panneau Variables.
• Community (Communauté): posez des questions et partagez des workflows avec d'autres développeurs sur le forum UiPath.