Fonctions lambda pour Bicep
Cet article décrit les fonctions lambda à utiliser dans Bicep. Les expressions lambda (ou fonctions lambda) sont 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 variable> => <expression>
Notes
Les fonctions lambda ne sont prises en charge que dans la version 0.10.X ou supérieure de Bicep CLI.
La fonction lambda Bicep 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 expressions lambda) à l’intérieur de l’accès au tableau de ressources ou de modules n’est pas prise en charge.
- L’utilisation de variables lambda à l’intérieur de la fonction
listKeys
n’est pas prise en charge. - L’utilisation de variables lambda à l’intérieur de la fonction reference n’est pas prise en charge.
filter(inputArray, lambda expression)
Filtre un tableau avec une fonction de filtrage personnalisée.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputArray | Oui | tableau | Tableau à filtrer. |
expression lambda | Oui | expression | L’expression lambda est appliquée à chaque élément d’un tableau d’entrée. Si le résultat est vrai, l'élément est inclus dans le tableau de sortie ; dans le cas contraire, l'élément sera supprimé. |
Tableau.
Les exemples suivants montrent comment utiliser la fonction filter
.
var dogs = [
{
name: 'Evie'
age: 5
interests: ['Ball', 'Frisbee']
}
{
name: 'Casper'
age: 3
interests: ['Other dogs']
}
{
name: 'Indy'
age: 2
interests: ['Butter']
}
{
name: 'Cira'
age: 8
interests: ['Rubs']
}
]
output oldDogs array = filter(dogs, dog => dog.age >=5)
output dogNameIndex array = filter(dogs, (val, i) => i < 2 && substring(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 ».
var itemForLoop = [for item in range(0, 10): item]
output filteredLoop array = filter(itemForLoop, i => i > 5)
output isEven array = filter(range(0, 10), i => 0 == i % 2)
Sorties 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(inputArray, lambda expression)
Crée un objet avec des valeurs de tableau à partir d’un tableau, à l’aide d’une condition de regroupement.
Espace de noms : sys.
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. |
Objet .
L’exemple suivant explique comment utiliser la fonction groupBy
.
var inputArray = ['foo', 'bar', 'baz']
output outObject object = groupBy(inputArray, x => substring(x, 0, 1))
La sortie de l’exemple précédent :
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(inputArray, lambda expression)
Applique une fonction de mappage personnalisée à chaque élément d’un tableau.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputArray | Oui | tableau | Tableau à mapper. |
expression lambda | Oui | expression | Expression lambda appliquée à chaque élément d’un tableau d’entrée, afin de générer le tableau de sortie. |
Tableau.
L’exemple suivant explique comment utiliser la fonction map
.
var 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']
}
]
output dogNames array = map(dogs, dog => dog.name)
output sayHi array = map(dogs, dog => 'Hello ${dog.name}!')
output mapArray array = map(range(0, length(dogs)), i => {
i: i
dog: dogs[i].name
greeting: 'Ahoy, ${dogs[i].name}!'
})
output mapArrayIndex array = map(dogs, (x, i) => { index: i, val: x.name})
Les sorties de l’exemple précédent sont les suivantes :
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(inputObject, lambda expression)
Crée un objet à partir d’un objet d’entrée à l’aide d’une expression lambda pour mapper des valeurs.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputObject | Oui | object | Objet à mapper. |
expression lambda | Oui | expression | Expression lambda utilisée pour mapper les valeurs. |
Objet.
L’exemple suivant explique comment utiliser la fonction mapValues
.
var inputObject = { foo: 'foo', bar: 'bar' }
output mapObject object = mapValues(inputObject, val => toUpper(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(inputArray, initialValue, lambda expression)
Réduit un tableau à l’aide d’une fonction de réduction personnalisée.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputArray | Oui | tableau | Tableau à réduire. |
initialValue | Oui | n'importe laquelle | Valeur initiale. |
expression lambda | Oui | expression | Expression lambda utilisée pour agréger la valeur actuelle et la valeur suivante. |
Tout.
Les exemples suivants montrent comment utiliser la fonction reduce
.
var 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']
}
]
var ages = map(dogs, dog => dog.age)
output totalAge int = reduce(ages, 0, (cur, next) => cur + next)
output totalAgeAdd1 int = reduce(ages, 1, (cur, next) => cur + next)
output oddAge int = reduce(ages, 0, (cur, next, i) => (i % 2 == 0) ? cur + next : cur)
Les sorties de l’exemple précédent sont les suivantes :
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).
output reduceObjectUnion object = reduce([
{ foo: 123 }
{ bar: 456 }
{ baz: 789 }
], {}, (cur, next) => union(cur, 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(inputArray, lambda expression)
Trie un tableau avec une fonction de tri personnalisée.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputArray | Oui | tableau | Tableau à trier. |
expression lambda | Oui | expression | Expression 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. |
Tableau.
L’exemple suivant explique comment utiliser la fonction sort
.
var 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']
}
]
output dogsByAge array = sort(dogs, (a, b) => a.age < 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(inputArray, lambda expression, [lambda expression])
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.
Espace de noms : sys.
Paramètre | Obligatoire | Type | Description |
---|---|---|---|
inputArray | Oui | tableau | Tableau utilisé pour créer un objet. |
expression lambda | Oui | expression | Expression lambda utilisée pour fournir le prédicat de clé. |
expression lambda | Non | expression | Expression lambda utilisée pour fournir la valeur de clé. |
Objet.
L’exemple suivant montre comment utiliser la fonction toObject
avec les deux paramètres requis :
var 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' ]
}
]
output dogsObject object = toObject(dogs, entry => 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.
output dogsObject object = toObject(dogs, entry => entry.name, entry => entry)
L’exemple suivant montre comment utiliser la fonction toObject
avec trois paramètres.
var 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' ]
}
}
]
output dogsObject object = toObject(dogs, entry => entry.name, entry => 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"]}} |