Créer des variables pour stocker et gérer des valeurs dans Azure Logic Apps

S’applique à : Azure Logic Apps (Consommation + Standard)

Cet article explique comment créer et utiliser des variables pour stocker des valeurs dans votre flux de travail d’application logique. Des variables peuvent, par exemple, vous aider à suivre le nombre d’exécutions d’une boucle. Pour itérer sur un tableau ou rechercher un élément spécifique dans un tableau, vous pouvez utiliser une variable qui référence le numéro d’index de chaque élément du tableau.

Vous pouvez créer des variables pour des types de données tels que entier, flottant, booléen, chaîne, tableau et objet. Après avoir créé une variable, vous pouvez effectuer d’autres tâches, par exemple :

Obtenir ou référencer la valeur de la variable.
Augmenter ou réduire la variable d’une valeur constante, opérations également appelées incrémenter et décrémenter.
Affecter une valeur différente à la variable.
Insérer, ou ajouter, la valeur de la variable à la fin d’une chaîne ou d’un tableau.

Les variables existent et sont globales uniquement au sein de l’instance de flux de travail d’application logique qui les crée. En outre, elles sont conservées dans toutes les itérations de boucle à l’intérieur d’une instance de flux de travail. Quand vous référencez une variable, utilisez le nom de celle-ci comme jeton, au lieu du nom de l’action qui est la façon habituelle de référencer les résultats d’une action.

Important

Par défaut, les itérations d’une boucle Pour chaque s’exécutent en parallèle. Quand vous utilisez des variables dans des boucles, exécutez la boucle séquentiellement afin que les variables retournent des résultats prévisibles.

Prérequis

Un compte et un abonnement Azure. Si vous n’avez pas encore d’abonnement, vous pouvez vous inscrire pour obtenir un compte Azure gratuitement.
Un flux de travail d’application logique dans lequel vous souhaitez créer la variable et un déclencheur qui démarre le flux de travail.

Avant que vous puissiez ajouter des actions pour la création et l’utilisation de variables, votre workflow d’application logique doit démarrer avec un déclencheur. Pour plus d’informations, consultez Ajouter un déclencheur ou une action pour générer un flux de travail.

Les étapes suivantes utilisent le portail Azure, mais avec l’extension Azure Logic Apps appropriée, vous pouvez également utiliser les outils suivants pour créer des flux de travail d’application logique :

Flux de travail de consommation : Visual Studio Code
Workflow Standard : Visual Studio Code

Certaines étapes diffèrent légèrement selon que vous disposez d’un flux de travail Consommation ou Standard.

Initialiser la variable

Vous pouvez créer une variable et déclarer son type de données et sa valeur initiale en utilisant d’une seule action dans votre flux de travail. Vous ne pouvez déclarer des variables qu’au niveau global, pas dans des étendues, des conditions ou des boucles.

Sur le Portail Azure, ouvrez votre flux de travail d’application logique dans le Concepteur.
Dans le concepteur, suivez ces étapes générales pour les flux de travail Consommation ou Standard afin d’ajouter une action nommée Initialize variables.

Fournissez les informations suivantes concernant votre variable :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Nom de la variable à initialiser
Type	Oui	< variable-type>	Type de données de la variable.
Valeur	Non	< valeur-départ>	Valeur initiale de votre variable. Conseil : bien que cette valeur soit facultative, il est recommandé de la définir afin de toujours savoir la valeur initiale de votre variable.

Pour créer plusieurs variables à la fois, sélectionnez Ajouter une variable.

L’exemple suivant montre les valeurs initiales de cet exemple de variable :

Continuez à ajouter les actions souhaitées pour votre scénario. Lorsque c’est chose faite, dans la barre d’outils du concepteur, sélectionnez Enregistrer.

Si vous passez du concepteur en mode code, l’exemple suivant montre comment l’action Initialiser les variables s’affiche dans votre définition de flux de travail, au format JSON (JavaScript Object Notation) :

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [ 
            {
               "name": "Count",
               "type": "Integer",
               "value": 0
            }
         ]
      },
      "runAfter": {}
   }
}

Les exemples suivants montrent d’autres types de variables :

Variable booléenne

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myBooleanVariable",
               "type": "boolean",
               "value": false
            }
         ]
      },
      "runAfter": {}
   }
},

Variable flottante

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myFloatVariable",
               "type": "float",
               "value": 1.99999
            }
         ]
      },
      "runAfter": {}
   }
},

Variable de chaîne

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myStringVariable",
               "type": "string",
               "value": "lorem ipsum"
            }
         ]
      },
      "runAfter": {}
   }
},

Variable d’objet

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "MyObjectVariable",
               "type": "object",
               "value": {
                  "ProductItem": {
                     "Name": "myProductName",
                     "ProductID": "000000"
                  }
               }
            }
         ]
      },
      "runAfter": {}
   }
},

Tableau d’entiers

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myArrayVariable",
               "type": "array",
               "value": [1, 2, 3]
            }
         ]
      },
      "runAfter": {}
   }
},

Tableau de chaînes

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myArrayVariable",
               "type": "array",
               "value": ["red", "orange", "yellow"]
            }
         ]
      },
      "runAfter": {}
   }
},

Obtenir la valeur d’une variable

Pour récupérer ou référencer le contenu d’une variable, vous pouvez utiliser la variables() fonction dans le concepteur de flux de travail et l’éditeur de vue de code. Quand vous référencez une variable, utilisez le nom de celle-ci comme jeton, au lieu du nom de l’action qui est la façon habituelle de référencer les résultats d’une action.

Par exemple, cette expression obtient les éléments de la variable tableau que vous crée dans ce guide à l’aide de la fonction variables(). La fonction string() retourne le contenu de la variable sous forme de chaîne : "1, 2, 3, red".

@{string(variables('myArrayVariable'))}

Incrémenter une variable

Pour augmenter ou incrémenter une variable d’une valeur constante, ajoutez l’action Incrémenter une variable à votre flux de travail. Cette action fonctionne uniquement avec les variables de type entier et flottant.

Dans le concepteur, suivez ces étapes générales pour les flux de travail Consommation ou Standard afin d’ajouter une action nommée Increment variables.

Pour cette action, vous devrez fournir les informations suivantes :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Nom de la variable à incrémenter
Valeur	Non	< valeur d'incrément>	Valeur utilisée pour incrémenter la variable. La valeur par défaut est `1`. Conseil : bien que cette valeur soit facultative, il est recommandé de la définir afin de toujours savoir la valeur spécifique de l’incrémentation de votre variable.

L’exemple suivant montre les exemples de valeurs pour cette action :

Lorsque vous avez terminé, enregistrez votre flux de travail. Dans la barre d’outils du Concepteur, sélectionnez Enregistrer.

Si vous passez du concepteur à l’éditeur de Code, voici comment l’action Incrémenter une variable s’affiche dans la définition de votre flux de travail, qui est au format JSON (JavaScript Object Notation) :

"actions": {
   "Increment_variable": {
      "type": "IncrementVariable",
      "inputs": {
         "name": "Count",
         "value": 1
      },
      "runAfter": {}
   }
},

Exemple : créer un compteur de boucle

Des variables sont couramment utilisées pour compter le nombre d’exécutions d’une boucle. Cet exemple montre comment créer et utiliser des variables pour cette tâche en créant une boucle qui compte les pièces jointes à un e-mail.

Dans le portail Azure, créez votre ressource d’application logique avec un flux de travail vide. Ajoutez un déclencheur qui vérifie la présence de nouveaux e-mails et pièces jointes.

Cet exemple utilise le déclencheur Office 365 Outlook quand un nouvel e-mail arrive. Vous pouvez configurer ce déclencheur de façon à ce qu’il s’active uniquement lorsque l’e-mail contient des pièces jointes. En revanche, vous pouvez utiliser n’importe quel connecteur qui vérifie la présence de nouveaux e-mails contenant des pièces jointes, tel que le connecteur Outlook.com.
Dans le déclencheur, pour vérifier la présence de pièces jointes et le passage de celles-ci au flux de travail de votre application logique, sélectionnez Oui pour ces propriétés :
- Uniquement avec pièce jointe
- Inclure des pièces jointes
Ajoutez l’action Initialize variables pour créer une variable entière nommée Count dont la valeur de début est définie sur 0.
Dans le concepteur, suivez ces étapes générales pour les flux de travail Consommation ou Standard afin d’ajouter une action nommée For each loop.
Dans la boucle, sélectionnez dans la zone nommée Sélectionner une sortie des étapes précédentes pour afficher les options d’entrée. Sélectionnez l’icône éclair pour afficher la liste de contenu dynamique. Dans la liste, sous À la réception d’un e-mail, sélectionnez Pièces jointes.

La propriété Pièces jointes transmet un tableau qui contient les pièces jointes à l’e-mail de la sortie du déclencheur dans la boucle pour que votre flux de travail effectue une itération.
Dans la boucle For each, sélectionnez Ajouter une action.
Suivez ces étapes générales pour le flux de travail Consommation ou Standard afin d’ajouter une action appelée Increment variable à la boucle.

Remarque

Assurez-vous que l’action Incrémenter une variable apparaît dans la boucle. Si l’action apparaît hors de la boucle, faites-la glisser dans la boucle.
Dans l’action Incrémenter une variable, dans la liste Nom, sélectionnez la variable Nombre. Définissez la propriété Valeur sur 1.
Sous la boucle, ajoutez une action qui vous envoie le nombre de pièces jointes. Dans l’action, incluez la valeur de la variable Nombre, par exemple :
Lorsque vous avez terminé, enregistrez votre flux de travail. Dans la barre d’outils du Concepteur, sélectionnez Enregistrer.

Tester votre workflow

Pour déclencher manuellement votre flux de travail, dans la barre d’outils du concepteur, sélectionnez Exécuter>Exécuter pour exécuter manuellement votre flux de travail.
Envoyez un e-mail avec une ou plusieurs des pièces jointes au compte de courrier que vous avez utilisé dans cet exemple.

Cette étape déclenche le déclencheur de flux de travail, qui crée et exécute une instance de flux de travail. Ensuite, le flux de travail vous envoie un message ou un e-mail indiquant le nombre de pièces jointes dans l’e-mail que vous avez envoyé.

Si vous passez du concepteur à l’éditeur de Code, voici comment la boucle Pour chaque s’affiche avec l’action Incrémenter la variable dans la définition de votre flux de travail, qui est au format JSON (JavaScript Object Notation) :

"actions": {
   "For_each": {
      "type": "Foreach",
      "actions": {
         "Increment_variable": {
           "type": "IncrementVariable",
            "inputs": {
               "name": "Count",
               "value": 1
            },
            "runAfter": {}
         }
      },
      "foreach": "@triggerBody()?['Attachments']",
      "runAfter": {
         "Initialize_variable": [ "Succeeded" ]
      }
   }
},

Décrémenter une variable

Pour diminuer ou décrémenter une variable d’une valeur constante spécifique, procédez de la même manière que pour incrémenter une variable, mais ajouter à la place l’action Décrémenter une variable à votre flux de travail. Cette action fonctionne uniquement avec les variables de type entier et flottant.

Le tableau suivant décrit les informations relatives à l’action Décrémenter une variable :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Nom de la variable à décrémenter
Valeur	Non	< décrément-valeur>	Valeur de la décrémentation de la variable. La valeur par défaut est 1. Conseil : bien que cette valeur soit facultative, il est recommandé de la définir afin de toujours savoir la valeur spécifique de la décrémentation de votre variable.

Si vous passez du concepteur à l’éditeur de Code, voici comment l’action Décrémenter une variable s’affiche dans la définition de votre flux de travail, qui est au format JSON (JavaScript Object Notation) :

"actions": {
   "Decrement_variable": {
      "type": "DecrementVariable",
      "inputs": {
         "name": "Count",
         "value": 1
      },
      "runAfter": {}
   }
},

Définir une variable

Pour attribuer une valeur différente à une variable, procédez de la même manière que pour incrémenter une variable sauf que vous devez :

Rechercher et sélectionner l’action Définir une variable à la place.
Fournissez le nom de la variable et la valeur à lui attribuer. Le type de données de la nouvelle valeur et de la variable doivent être le même. La valeur est requise, car cette action n’a pas de valeur par défaut.

Le tableau suivant décrit les informations relatives à l’action Définir une variable :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Nom de la variable à modifier
Valeur	Oui	< new-value>	Valeur que vous souhaitez attribuer à la variable. Le type de données des deux doit être identique.

Remarque

Sauf si vous incrémentez ou décrémentez des variables, la modification de variables dans des boucles peut produire des résultats inattendus, car les boucles s’exécutent en parallèle ou simultanément par défaut. Dans ce cas, essayez de définir votre boucle pour qu’elle s’exécute de manière séquentielle. Par exemple, lorsque vous souhaitez référencer la valeur de la variable à l’intérieur de la boucle et attendez la même valeur au début et à la fin de cette instance de boucle, procédez comme suit pour modifier la façon dont la boucle s’exécute :

Sélectionnez votre boucle pour afficher le volet d’informations, puis sélectionnez Paramètres.
Dans la section Général , sous Contrôle d’accès concurrentiel, remplacez le paramètre Désactivé par Activé.
Faites glisser le curseur Degré de parallélisme vers 1.

Si vous passez du concepteur à l’éditeur de Code, voici comment l’action Définir la variable s’affiche dans la définition de votre flux de travail, qui est au format JSON (JavaScript Object Notation) :

Cet exemple change la valeur actuelle de la variable Count vers une autre valeur :

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [ {
               "name": "Count",
               "type": "Integer",
               "value": 0
          } ]
      },
      "runAfter": {}
   },
   "Set_variable": {
      "type": "SetVariable",
      "inputs": {
         "name": "Count",
         "value": 100
      },
      "runAfter": {
         "Initialize_variable": [ "Succeeded" ]
      }
   }
},

Ajouter à une variable

Pour les variables qui stockent des chaînes ou des tableaux, vous pouvez insérer ou ajouter la valeur d’une variable à la fin de ces chaînes ou des tableaux. Vous pouvez suivre les étapes d’incrémentation d’une variable avec les exceptions suivantes :

Recherchez et sélectionnez une des actions suivantes, selon que votre variable est une chaîne ou un tableau :
- Ajouter à une variable chaîne
- Ajouter à une variable tableau
Spécifiez la valeur à ajouter à la fin de la chaîne ou du tableau. Cette valeur est requise.

Le tableau suivant décrit les informations relatives aux actions Ajouter à... :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Nom de la variable à modifier
Valeur	Oui	< ajouter-valeur>	Valeur que vous souhaitez ajouter, qui peut être de tout type

Si vous passez du concepteur à l’éditeur de Code, voici comment l’action Ajouter à une variable tableau s’affiche dans la définition de votre flux de travail, qui est au format JSON (JavaScript Object Notation).

Cet exemple crée une variable tableau et ajoute une autre valeur à la fin du tableau. Votre résultat est une variable mise à jour qui contient ce tableau : [1,2,3,"red"].

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [ {
            "name": "myArrayVariable",
            "type": "Array",
            "value": [1, 2, 3]
         } ]
      },
      "runAfter": {}
   },
   "Append_to_array_variable": {
      "type": "AppendToArrayVariable",
      "inputs": {
         "name": "myArrayVariable",
         "value": "red"
      },
      "runAfter": {
        "Initialize_variable": [ "Succeeded" ]
      }
   }
},

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-08-19