Funciones lambda para plantillas de Resource Manager
En este artículo se describen las funciones lambda que se usarán en plantillas de ARM. Las funciones lambda son básicamente bloques de código que se pueden pasar como argumentos. Pueden tomar varios parámetros, pero se restan a una sola línea de código. En Bicep, la expresión lambda tiene este formato:
lambda(<lambda variable>, [<lambda variable>, ...], <expression>)
Sugerencia
Se recomienda Bicep porque ofrece las mismas funcionalidades que las plantillas de ARM y la sintaxis es más fácil de usar. Para obtener más información, consulte las funciones de implementación.
Limitaciones
La función lambda de plantilla de ARM tiene estas limitaciones:
- La expresión lambda solo se puede especificar directamente como argumentos de función en estas funciones:
filter(), ,map()mapValues()groupBy(),reduce(), , y .sort()toObject() - Actualmente no se admite el uso de variables lambda (las variables temporales usadas en las funciones lambda) dentro del acceso a la matriz de recursos o módulos.
- Actualmente no se admite el uso de variables lambda dentro de la función
listKeys. - El uso de variables lambda dentro de la función de referencia no se admite actualmente.
filter
filter(inputArray, lambda function)
Filtra una matriz con una función de filtrado personalizada.
En Bicep, use la función filter.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz que se va a filtrar. |
| función lambda | Sí | expresión | Función lambda aplicada a cada elemento de matriz de entrada. Si es falso, el elemento se filtra fuera de la matriz de salida. |
Valor devuelto
Matriz .
Ejemplos
En el siguiente ejemplo, se muestra cómo usar la función 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'))))]"
}
}
}
Salidas del ejemplo anterior:
| Nombre | Tipo | Value |
|---|---|---|
| oldDogs | Array | [{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}] |
| dogNameIndex | Matriz | [{"name":"Casper","age":3,"interests":["Other dogs"]}] |
oldDogs enumera los perros que son cinco o más antiguos ; dogNameIndex identifica los perros cuyo número de índice es menor que dos y cuyo nombre comienza por la letra "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))))]"
}
}
}
El resultado del ejemplo anterior es:
| Nombre | Tipo | Value |
|---|---|---|
| filteredLoop | Array | [6, 7, 8, 9] |
| isEven | Array | [0, 2, 4, 6, 8] |
filterdLoop muestra los números de una matriz que son mayores que 5; e isEven muestra los números pares de la matriz.
groupBy
groupBy(inputArray, lambda expression)
Crea un objeto con valores de matriz de una matriz mediante una condición de agrupación.
En Bicep, use la función groupBy.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz para la agrupación. |
| Expresión lambda | Sí | expresión | La expresión lambda se aplica a cada elemento de la matriz de entrada y se agrupan los elementos mediante la condición de agrupación. |
Valor devuelto
Objeto .
Ejemplos
En el ejemplo siguiente se muestra cómo usar la función 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 salida del ejemplo anterior muestra los perros que son cinco o más antiguos:
| Nombre | Tipo | Valor |
|---|---|---|
| outObject | Object | {"f":["foo"],"b":["bar","baz"]} |
outObject muestra un objeto que agrupa los elementos de matriz por sus primeras letras.
map
map(inputArray, lambda function)
Aplica una función de asignación personalizada a cada elemento de una matriz.
En Bicep, use la función map.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz que se va a asignar. |
| función lambda | Sí | expresión | Función lambda aplicada a cada elemento de matriz de entrada para generar la matriz de salida. |
Valor devuelto
Matriz .
Ejemplo
En el ejemplo siguiente se muestra cómo usar la función 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)))]"
}
}
}
El resultado del ejemplo anterior es:
| Nombre | Tipo | Value |
|---|---|---|
| dogNames | Array | ["Evie","Casper","Indy","Kira"] |
| sayHi | Array | ["Hello Evie!","Hello Casper!","Hello Indy!","Hello Kira!"] |
| mapArray | Matriz | [{"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 | Matriz | [{"index":0,"val":"Evie"},{"index":1,"val":"Casper"},{"index":2,"val":"Indy"},{"index":3,"val":"Kira"}] |
dogNames muestra los nombres de perro de la matriz de objetos; sayHi concatena "Hello" y cada uno de los nombres de los perros; mapArray y mapArrayIndex crean otras dos matrices de objetos.
mapValues
mapValues(inputObject, lambda expression)
Crea un objeto a partir de un objeto de entrada, con una expresión lambda para asignar valores.
En Bicep, use la función mapValues.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputObject | Sí | objeto | Objeto que se va a asignar. |
| Expresión lambda | Sí | expresión | Expresión lambda usada para asignar los valores. |
Valor devuelto
Objeto.
Ejemplo
En el ejemplo siguiente se muestra cómo usar la función 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'))))]"
}
}
}
El resultado del ejemplo anterior es:
| Nombre | Tipo | Valor |
|---|---|---|
| mapObject | Object | {foo: "FOO", bar: "BAR"} |
mapObject crea otro objeto con los valores en mayúsculas.
reduce
reduce(inputArray, initialValue, lambda function)
Reduce una matriz con una función de reducción personalizada.
En Bicep, use la función reduce.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz que se va a reducir. |
| initialValue | Sí | cualquiera | Valor inicial. |
| función lambda | Sí | expresión | Función lambda usada para agregar el valor actual y el valor siguiente. |
Valor devuelto
Cualquiera.
Ejemplo
En el siguiente ejemplo, se muestra cómo usar la función 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'))))]"
}
}
}
El resultado del ejemplo anterior es:
| Nombre | Tipo | Value |
|---|---|---|
| totalAge | int | 18 |
| totalAgeAdd1 | int | 19 |
| oddAge | int | 7 |
totalAge suma las edades de los perros; totalAgeAdd1 tiene un valor inicial de 1 y agrega todas las edades del perro a los valores iniciales. oddAge suma las edades de los perros que se encuentran en índices pares, específicamente 5 (Evie) y 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'))))]"
}
}
}
El resultado del ejemplo anterior es:
| Nombre | Tipo | Value |
|---|---|---|
| reduceObjectUnion | object | {"foo":123,"bar":456,"baz":789} |
La función de unión devuelve un único objeto con todos los elementos de los parámetros. La llamada de función combina los pares clave-valor de los objetos en un nuevo objeto.
sort
sort(inputArray, lambda function)
Ordena una matriz con una función de ordenación personalizada.
En Bicep, use la función sort.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | La matriz a ordenar. |
| función lambda | Sí | expresión | Función lambda usada para comparar dos elementos de matriz para ordenar. Si es true, el segundo elemento se ordenará después del primero de la matriz de salida. |
Valor devuelto
Matriz .
Ejemplo
En el ejemplo siguiente se muestra cómo usar la función 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 salida del ejemplo anterior ordena los objetos dog del más joven al más antiguo:
| Nombre | Tipo | Value |
|---|---|---|
| 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])
Convierte una matriz en un objeto con una función de clave personalizada y una función de valor personalizada opcional. Consulta elementos sobre cómo convertir un objeto en una matriz.
En Bicep, use la función toObject.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz utilizada para crear un objeto. |
| función lambda | Sí | expresión | Función lambda usada para proporcionar el predicado de clave. |
| función lambda | No | expresión | Función lambda usada para proporcionar el predicado de valor. |
Valor devuelto
Objeto.
Ejemplo
En el ejemplo siguiente se muestra cómo usar la función toObject con los dos parámetros necesarios:
{
"$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))]"
}
}
}
En el ejemplo anterior se genera un objeto basado en una matriz.
| Nombre | Tipo | Value |
|---|---|---|
| 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 siguiente función toObject con el tercer parámetro proporciona la misma salida.
"outputs": {
"dogsObject": {
"type": "object",
"value": "[toObject(variables('dogs'), lambda('entry', lambdaVariables('entry').name), lambda('entry', lambdaVariables('entry')))]"
}
}
En el ejemplo siguiente se muestra cómo usar la función toObject con tres parámetros.
{
"$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))]"
}
}
}
En el ejemplo anterior se genera un objeto basado en una matriz.
| Nombre | Tipo | Value |
|---|---|---|
| dogsObject | Object | {"Evie":{"age":5,"interests":["Ball","Frisbee"]},"Casper":{"age":3,"interests":["Other dogs"]},"Indy":{"age":2,"interests":["Butter"]},"Kira":{"age":8,"interests":["Rubs"]}} |
Pasos siguientes
- Consulte Funciones de plantilla: matrices para obtener más funciones de plantilla relacionadas con matrices.
Comentaris
Properament: al llarg del 2024 eliminarem gradualment GitHub Issues com a mecanisme de retroalimentació del contingut i el substituirem per un nou sistema de retroalimentació. Per obtenir més informació, consulteu: https://aka.ms/ContentUserFeedback.
Envieu i consulteu els comentaris de