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

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

Pour stocker et transmettre des valeurs dans votre flux de travail, créez des variables. Les variables prennent en charge les valeurs d’entier, float, booléennes, chaînes, tableaux et objets.

Des variables peuvent, par exemple, vous aider à suivre le nombre d’exécutions d’une boucle. Pour itérer sur un tableau ou vérifier un tableau pour un élément spécifique, utilisez une variable pour référencer le numéro d’index de chaque élément du tableau.

Après avoir créé une variable, choisissez une tâche :

Créer une variable
Obtenez la valeur d’une variable
Incrementer une variable
Décrémenter une variable
Modifier la valeur d’une variable
Ajouter à une variable de chaîne ou de tableau
Exemple : compter les pièces jointes aux e-mails avec une boucle

Prérequis

Un compte et un abonnement Azure. Obtenez un compte Azure gratuit.
Le workflow de l’application Logic où vous voulez créer la variable, y compris un déclencheur qui lance le workflow.

Avant de pouvoir ajouter des actions pour créer et travailler avec des variables, votre flux de travail doit commencer par un déclencheur comme première étape.

Ce guide utilise le portail Azure, mais vous pouvez utiliser Visual Studio Code et l’extension Azure Logic Apps correspondante pour créer des flux de travail Logic App :
- Flux de travail de consommation : Visual Studio Code
- Workflow Standard : Visual Studio Code

Considérations pour travailler avec des variables

Par défaut, pour chaque boucle, les itérations s’exécutent en parallèle. Pour s’assurer que les variables d’une boucle produisent des résultats prévisibles, exécutez la boucle séquentiellement.
Les variables existent et ne sont globales que dans le flux de travail qui les crée.
Les variables persistent uniquement à travers les itérations de boucle dans ce flux de travail.
Référencez une variable par son nom, et non par le nom de l’action qui a créé la variable, ce qui est la manière habituelle de référencer les sorties d’une action.

Initialiser la variable

Pour créer une variable, ajoutez l’action Initialiser la variable à votre flux de travail. Vous ne pouvez déclarer les variables qu’au niveau global du workflow, pas en portées, conditions ou boucles.

Sur le Portail Azure, ouvrez votre flux de travail d’application logique dans le Concepteur.
Dans le concepteur, ajoutez l’action nommée variable Initialize en suivant les étapes générales basées sur votre type de workflow :
- Consommation
- Standard

Fournissez les informations suivantes concernant votre variable :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Le nom attribué à la variable.
Type	Oui	< variable-type>	Type de données pour 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.

Par exemple, cette action Initialiser la variable contient le nom, le type de données et la valeur initiale de la 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 de la vue designer à la vue code, l’exemple suivant montre comment l’action Initialize variable apparaît dans votre définition de workflow, qui est au format JavaScript Object Notation (JSON) :

"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, utilisez la variables() fonction dans le concepteur de workflow et l’éditeur de code view. 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, ajoutez l’action nommée variable Increment en suivant les étapes générales basées sur votre type de workflow :
- Consommation
- Standard

Pour cette action, vous devrez fournir les informations suivantes :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Le nom de la variable à incrémenter.
Valeur	Non	< valeur d'incrément>	La valeur à utiliser 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 : compter les pièces jointes aux e-mails avec une boucle

Dans cet exemple, vous initialiserez un compteur à zéro, vous incrémentez le compteur une fois pour chaque pièce jointe d’email, puis vous retournez le nombre total de pièces jointes.

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 nommé When a new email received. Configurez ce déclencheur uniquement lorsque l’email 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, sélectionnez Oui pour les propriétés suivantes afin de vérifier la présence de pièces jointes et de les transférer à votre flux de travail :
- Uniquement avec pièce jointe
- Inclure des pièces jointes
Ajoutez l’action Initialiser la variable pour créer une variable entière nommée Count qui commence à 0.
Dans le concepteur, ajoutez l’action nommée Pour chaque en suivant les étapes générales basées sur votre type de workflow :
- Consommation
- Standard
Dans la boucle, suivez ces étapes :
1. Sélectionnez dans la case Sélectionner une sortie parmi les étapes précédentes pour consulter les options d’entrée.
2. Sélectionnez l’icône éclair pour afficher la liste de contenu dynamique.
3. 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.
Dans le concepteur, ajoutez l’action nommée variable Increment en suivant les étapes générales basées sur votre type de workflow :
- Consommation
- Standard
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.

Pour cette action, vous devrez fournir les informations suivantes :

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Le nom de la variable à changer.
Valeur	Oui	< nouvelle valeur>	Valeur que vous souhaitez attribuer à la variable. Assurez-vous que la variable et la nouvelle valeur ont le même type de données. La valeur est requise, car cette action n’a pas de valeur par défaut.

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 de la vue designer à la vue code, l’exemple suivant montre comment l’action Set variable apparaît dans votre définition de workflow, qui est au format JSON, et modifie la Count valeur actuelle de la variable en 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. Suivez les étapes pour incrémenter 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.

Propriété	Obligatoire	Valeur	Descriptif
Nom	Oui	< nom de variable>	Le nom de la variable à changer.
Valeur	Oui	< ajouter-valeur>	La valeur que vous souhaitez ajouter, qui peut avoir n’importe quel 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" ]
      }
   }
},

Commentaires

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

Last updated on 2026-09-11