Fonctions Lambda pour les modèles ARM
Cet article décrit les fonctions lambda à utiliser dans les modèles ARM. Les fonctions lambda sont essentiellement des blocs de code qui peuvent être passés en tant qu’argument. Elles peuvent prendre plusieurs paramètres, mais sont limitées à une seule ligne de code. Dans Bicep, une expression lambda est au format suivant :
lambda(<lambda variable>, [<lambda variable>, ...], <expression>)
Conseil
Nous recommandons Bicep, parce qu’il offre les mêmes fonctionnalités que les modèles ARM et que la syntaxe est plus facile d’utilisation. Pour plus d’informations, reportez-vous aux fonctions de déploiement.
Limites
La fonction lambda de modèle ARM présente les limitations suivantes :
- L’expression lambda ne peut être spécifiée que directement en tant qu’arguments de fonction dans ces fonctions :
filter(), ,groupBy(),map(),mapValues(),reduce(),sort()ettoObject(). - L’utilisation de variables lambda (variables temporaires utilisées dans les fonctions lambda) à l’intérieur de l’accès au tableau de ressources ou de modules n’est pas prise en charge pour le moment.
- L’utilisation de variables lambda à l’intérieur de la fonction
listKeysn’est pas prise en charge. - L’utilisation de variables lambda à l’intérieur de la fonction reference n’est pas prise en charge.
filter
filter(inputArray, lambda function)
Filtre un tableau avec une fonction de filtrage personnalisée.
Dans Bicep, utilisez la fonction filter.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Tableau à filtrer. |
| fonction lambda | Oui | expression | Fonction lambda appliquée à chaque élément d’un tableau d’entrée. Si la valeur est fausse, l’élément sera exclu du tableau de sortie. |
Valeur retournée
Tableau.
Exemples
Les exemples suivants montrent comment utiliser la fonction filter.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
},
{
"name": "Casper",
"age": 3,
"interests": [
"Other dogs"
]
},
{
"name": "Indy",
"age": 2,
"interests": [
"Butter"
]
},
{
"name": "Kira",
"age": 8,
"interests": [
"Rubs"
]
}
]
},
"resources": [],
"outputs": {
"oldDogs": {
"type": "array",
"value": "[filter(variables('dogs'), lambda('dog', greaterOrEquals(lambdaVariables('dog').age, 5)))]"
},
"dogNameIndex": {
"type": "array",
"value": "[filter(variables('dogs'), lambda('val', 'i', and(less(lambdaVariables('i'), 2), equals(substring(lambdaVariables('val').name, 0, 1), 'C'))))]"
}
}
}
Sorties de l’exemple précédent :
| Nom | Type | Valeur |
|---|---|---|
| oldDogs | Array | [{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}] |
| dogNameIndex | Tableau | [{"name » :"Casper »,"age » :3,"interests » :["Autres chiens"]}] |
oldDogs répertorie les chiens qui sont cinq ou plus âgés ; dogNameIndex identifie les chiens dont le numéro d’index est inférieur à deux et dont le nom commence par la lettre « C ».
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"copy": [
{
"name": "itemForLoop",
"count": "[length(range(0, 10))]",
"input": "[range(0, 10)[copyIndex('itemForLoop')]]"
}
]
},
"resources": [],
"outputs": {
"filteredLoop": {
"type": "array",
"value": "[filter(variables('itemForLoop'), lambda('i', greater(lambdaVariables('i'), 5)))]"
},
"isEven": {
"type": "array",
"value": "[filter(range(0, 10), lambda('i', equals(0, mod(lambdaVariables('i'), 2))))]"
}
}
}
La sortie de l’exemple précédent :
| Nom | Type | Valeur |
|---|---|---|
| filteredLoop | Array | [6, 7, 8, 9] |
| isEven | Array | [0, 2, 4, 6, 8] |
filterdLoop affiche les nombres d’un tableau qui sont supérieurs à 5, et isEven affiche les nombres pairs du tableau.
groupBy
groupBy(inputArray, lambda expression)
Crée un objet avec des valeurs de tableau à partir d’un tableau, à l’aide d’une condition de regroupement.
Dans Bicep, utilisez la fonction groupBy.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Le tableau pour le regroupement. |
| expression lambda | Oui | expression | L’expression lambda est appliquée à chaque élément de tableau d’entrée et regroupe les éléments à l’aide de la condition de regroupement. |
Valeur retournée
Objet .
Exemples
L’exemple suivant explique comment utiliser la fonction groupBy.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"inputArray": [
"foo",
"bar",
"baz"
]
},
"resources": [],
"outputs": {
"outObject": {
"type": "object",
"value": "[groupBy(variables('inputArray'), lambda('x', substring(lambdaVariables('x'), 0, 1)))]"
}
}
}
La sortie de l’exemple précédent montre les chiens qui ont cinq ans ou plus :
| Nom | Type | Value |
|---|---|---|
| outObject | Object | {"f":["foo"],"b":["bar","baz"]} |
outObject affiche un objet qui regroupe les éléments de tableau par leurs premières lettres.
map
map(inputArray, lambda function)
Applique une fonction de mappage personnalisée à chaque élément d’un tableau.
Dans Bicep, utilisez la fonction map.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Tableau à mapper. |
| fonction lambda | Oui | expression | Fonction lambda appliquée à chaque élément d’un tableau d’entrée afin de générer le tableau de sortie. |
Valeur retournée
Tableau.
Exemple
L’exemple suivant explique comment utiliser la fonction map.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
},
{
"name": "Casper",
"age": 3,
"interests": [
"Other dogs"
]
},
{
"name": "Indy",
"age": 2,
"interests": [
"Butter"
]
},
{
"name": "Kira",
"age": 8,
"interests": [
"Rubs"
]
}
]
},
"resources": [],
"outputs": {
"dogNames": {
"type": "array",
"value": "[map(variables('dogs'), lambda('dog', lambdaVariables('dog').name))]"
},
"sayHi": {
"type": "array",
"value": "[map(variables('dogs'), lambda('dog', format('Hello {0}!', lambdaVariables('dog').name)))]"
},
"mapArray": {
"type": "array",
"value": "[map(range(0, length(variables('dogs'))), lambda('i', createObject('i', lambdaVariables('i'), 'dog', variables('dogs')[lambdaVariables('i')].name, 'greeting', format('Ahoy, {0}!', variables('dogs')[lambdaVariables('i')].name))))]"
},
"mapArrayIndex": {
"type": "array",
"value": "[map(variables('dogs'), lambda('x', 'i', createObject('index', lambdaVariables('i'), 'val', lambdaVariables('x').name)))]"
}
}
}
La sortie de l’exemple précédent est :
| Nom | Type | Valeur |
|---|---|---|
| dogNames | Array | ["Evie","Casper","Indy","Kira"] |
| sayHi | Array | ["Hello Evie!","Hello Casper!","Hello Indy!","Hello Kira!"] |
| mapArray | Array | [{"i":0,"dog":"Evie","greeting":"Ahoy, Evie!"},{"i":1,"dog":"Casper","greeting":"Ahoy, Casper!"},{"i":2,"dog":"Indy","greeting":"Ahoy, Indy!"},{"i":3,"dog":"Kira","greeting":"Ahoy, Kira!"}] |
| mapArrayIndex | Tableau | [{"index » :0,"val » :"Evie"},{"index » :1,"val » :"Casper"},{"index » :2,"val » :"Indy"},{"index » :3,"val » :"Kira"}] |
dogNames affiche les noms des chiens à partir du tableau d’objets ; sayHi concatène « Hello » et chacun des noms de chiens ; mapArray et mapArrayIndex créent deux autres tableaux d’objets.
mapValues
mapValues(inputObject, lambda expression)
Crée un objet à partir d’un objet d’entrée à l’aide d’une expression lambda pour mapper des valeurs.
Dans Bicep, utilisez la fonction mapValues.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputObject | Oui | object | Objet à mapper. |
| expression lambda | Oui | expression | Expression lambda utilisée pour mapper les valeurs. |
Valeur retournée
Objet.
Exemple
L’exemple suivant explique comment utiliser la fonction mapValues.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"inputObject": {
"foo": "foo",
"bar": "bar"
}
},
"resources": [],
"outputs": {
"mapObject": {
"type": "object",
"value": "[mapValues(variables('inputObject'), lambda('val', toUpper(lambdaVariables('val'))))]"
}
}
}
La sortie de l’exemple précédent est :
| Nom | Type | Value |
|---|---|---|
| mapObject | Object | {foo : « FOO », bar : « BAR »} |
mapObject crée un autre objet avec les valeurs en majuscules.
reduce
reduce(inputArray, initialValue, lambda function)
Réduit un tableau à l’aide d’une fonction de réduction personnalisée.
Dans Bicep, utilisez la fonction reduce.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Tableau à réduire. |
| initialValue | Oui | n'importe laquelle | Valeur initiale. |
| fonction lambda | Oui | expression | Fonction lambda utilisée pour agréger la valeur actuelle et la valeur suivante. |
Valeur retournée
Tout.
Exemple
Les exemples suivants montrent comment utiliser la fonction reduce.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
},
{
"name": "Casper",
"age": 3,
"interests": [
"Other dogs"
]
},
{
"name": "Indy",
"age": 2,
"interests": [
"Butter"
]
},
{
"name": "Kira",
"age": 8,
"interests": [
"Rubs"
]
}
],
"ages": "[map(variables('dogs'), lambda('dog', lambdaVariables('dog').age))]"
},
"resources": [],
"outputs": {
"totalAge": {
"type": "int",
"value": "[reduce(variables('ages'), 0, lambda('cur', 'next', add(lambdaVariables('cur'), lambdaVariables('next'))))]"
},
"totalAgeAdd1": {
"type": "int",
"value": "[reduce(variables('ages'), 1, lambda('cur', 'next', add(lambdaVariables('cur'), lambdaVariables('next'))))]"
},
"oddAge": {
"type": "int",
"value": "[reduce(variables('ages'), 0, lambda('cur', 'next', 'i', if(equals(mod(lambdaVariables('i'), 2), 0), add(lambdaVariables('cur'), lambdaVariables('next')), lambdaVariables('cur'))))]"
}
}
}
La sortie de l’exemple précédent est :
| Nom | Type | Valeur |
|---|---|---|
| totalAge | int | 18 |
| totalAgeAdd1 | int | 19 |
| oddAge | int | 7 |
totalAge additionne l’âge des chiens. totalAgeAdd1 a une valeur initiale de 1, et ajoute tous les âges des chiens aux valeurs initiales. oddAge additionne les âges des chiens situés à des indices pairs, en particulier 5 (Evie) et 2 (Indy).
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"reduceObjectUnion": {
"type": "object",
"value": "[reduce(createArray(createObject('foo', 123), createObject('bar', 456), createObject('baz', 789)), createObject(), lambda('cur', 'next', union(lambdaVariables('cur'), lambdaVariables('next'))))]"
}
}
}
La sortie de l’exemple précédent est :
| Nom | Type | Valeur |
|---|---|---|
| reduceObjectUnion | object | {"foo":123,"bar":456,"baz":789} |
La fonction union retourne un objet unique avec tous les éléments à partir des paramètres. L’appel de fonction associe les paires clé-valeur des objets dans un nouvel objet.
sort
sort(inputArray, lambda function)
Trie un tableau avec une fonction de tri personnalisée.
Dans Bicep, utilisez la fonction sort.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Tableau à trier. |
| fonction lambda | Oui | expression | Fonction lambda utilisée pour comparer deux éléments de tableau à des fins de classement. Si la valeur est true, le deuxième élément sera placé après le premier dans le tableau de sortie. |
Valeur retournée
Tableau.
Exemple
L’exemple suivant explique comment utiliser la fonction sort.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
},
{
"name": "Casper",
"age": 3,
"interests": [
"Other dogs"
]
},
{
"name": "Indy",
"age": 2,
"interests": [
"Butter"
]
},
{
"name": "Kira",
"age": 8,
"interests": [
"Rubs"
]
}
]
},
"resources": [],
"outputs": {
"dogsByAge": {
"type": "array",
"value": "[sort(variables('dogs'), lambda('a', 'b', less(lambdaVariables('a').age, lambdaVariables('b').age)))]"
}
}
}
La sortie de l’exemple précédent trie les objets chiens du plus jeune au plus âgé :
| Nom | Type | Valeur |
|---|---|---|
| dogsByAge | Array | [{"name":"Indy","age":2,"interests":["Butter"]},{"name":"Casper","age":3,"interests":["Other dogs"]},{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}] |
toObject
toObject(inputArray, lambda function, [lambda function])
Convertit un tableau en objet avec une fonction de clé personnalisée et une fonction de valeur personnalisée facultative. Consultez les éléments relatifs à la conversion d’un objet en tableau.
Dans Bicep, utilisez la fonction toObject.
Paramètres
| Paramètre | Obligatoire | Type | Description |
|---|---|---|---|
| inputArray | Oui | tableau | Tableau utilisé pour créer un objet. |
| fonction lambda | Oui | expression | Fonction lambda utilisée pour fournir le prédicat de clé. |
| fonction lambda | Non | expression | Fonction lambda utilisée pour fournir le prédicat de valeur. |
Valeur retournée
Objet.
Exemple
L’exemple suivant montre comment utiliser la fonction toObject avec les deux paramètres requis :
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
},
{
"name": "Casper",
"age": 3,
"interests": [
"Other dogs"
]
},
{
"name": "Indy",
"age": 2,
"interests": [
"Butter"
]
},
{
"name": "Kira",
"age": 8,
"interests": [
"Rubs"
]
}
]
},
"resources": [],
"outputs": {
"dogsObject": {
"type": "object",
"value": "[toObject(variables('dogs'), lambda('entry', lambdaVariables('entry').name))]"
}
}
}
L’exemple précédent génère un objet basé sur un tableau.
| Nom | Type | Valeur |
|---|---|---|
| dogsObject | Object | {"Evie":{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},"Casper" :{"name":"Casper","age":3,"interests":["Other dogs"]},"Indy" :{"name":"Indy","age":2,"interests":["Butter"]},"Kira" :{"name":"Kira","age":8,"interests":["Rubs"]}} |
La fonction toObject suivante, avec le troisième paramètre, fournit le même résultat.
"outputs": {
"dogsObject": {
"type": "object",
"value": "[toObject(variables('dogs'), lambda('entry', lambdaVariables('entry').name), lambda('entry', lambdaVariables('entry')))]"
}
}
L’exemple suivant montre comment utiliser la fonction toObject avec trois paramètres.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"dogs": [
{
"name": "Evie",
"properties": {
"age": 5,
"interests": [
"Ball",
"Frisbee"
]
}
},
{
"name": "Casper",
"properties": {
"age": 3,
"interests": [
"Other dogs"
]
}
},
{
"name": "Indy",
"properties": {
"age": 2,
"interests": [
"Butter"
]
}
},
{
"name": "Kira",
"properties": {
"age": 8,
"interests": [
"Rubs"
]
}
}
]
},
"resources": [],
"outputs": {
"dogsObject": {
"type": "object",
"value": "[toObject(variables('dogs'), lambda('entry', lambdaVariables('entry').name), lambda('entry', lambdaVariables('entry').properties))]"
}
}
}
L’exemple précédent génère un objet basé sur un tableau.
| Nom | Type | Valeur |
|---|---|---|
| dogsObject | Object | {"Evie":{"age":5,"interests":["Ball","Frisbee"]},"Casper" :{"age":3,"interests":["Other dogs"]},"Indy" :{"age":2,"interests":["Butter"]},"Kira" :{"age":8,"interests" :["Rubs"]}} |
Étapes suivantes
- Voir Fonctions de modèle – tableaux pour plus d'informations sur les fonctions de modèles liées aux tableaux.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour