Funções do Lambda para modelos ARM

Artigo
05/29/2024

Este artigo descreve as funções lambda a serem usadas em modelos ARM. As funções do Lambda são essencialmente blocos de código que podem ser passados como um argumento. Eles podem ter vários parâmetros, mas são restritos a uma única linha de código. No Bicep, a expressão lambda está neste formato:

lambda(<lambda variable>, [<lambda variable>, ...], <expression>)

Gorjeta

Recomendamos o Bicep porque ele oferece os mesmos recursos que os modelos ARM e a sintaxe é mais fácil de usar. Para saber mais, consulte Funções de implantação .

Limitações

A função lambda do modelo ARM tem estas limitações:

A expressão do Lambda só pode ser especificada diretamente como argumentos de função nessas funções: , , , , mapValues()reduce(), sort(), e toObject(). map()groupBy()filter()
O uso de variáveis lambda (as variáveis temporárias usadas nas funções lambda) dentro do acesso à matriz de recursos ou módulos não é suportado no momento.
O uso de variáveis lambda dentro da listKeys função não é suportado no momento.
Atualmente, não há suporte para o uso de variáveis lambda dentro da função de referência .

filtrar

filter(inputArray, lambda function)

Filtra uma matriz com uma função de filtragem personalizada.

No Bicep, use a função de filtro .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz a ser filtrada.
Função lambda	Sim	expressão	A função lambda aplicada a cada elemento de matriz de entrada. Se false, o item é filtrado para fora da matriz de saída.

Valor devolvido

Uma matriz.

Exemplos

Os exemplos a seguir mostram como usar a filter função.

{
  "$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'))))]"
    }
  }
}

As saídas do exemplo anterior:

Nome	Tipo	valor
velhosCães	Matriz	[{"nome":"Evie","idade":5,"interesses":["Bola","Frisbee"]},{"nome":"Kira","idade":8,"interesses":["Rubs"]}]
dogNameIndex	Matriz	[{"nome":"Casper","idade":3,"interesses":["Outros cães"]}]

oldDogs lista os cães com cinco anos ou mais; dogNameIndex identifica os cães cujo número de índice é inferior a dois e cujo nome começa com a 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))))]"
    }
  }
}

A saída do exemplo anterior:

Nome	Tipo	valor
filteredLoop	Matriz	[6, 7, 8, 9]
éMesmo	Matriz	[0, 2, 4, 6, 8]

filterdLoop mostra os números em uma matriz que são maiores que 5; e isEven mostra os números pares na matriz.

groupBy

groupBy(inputArray, lambda expression)

Cria um objeto com valores de matriz de uma matriz, usando uma condição de agrupamento.

No Bicep, use a função groupBy .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz para agrupamento.
expressão lambda	Sim	expressão	A expressão lambda é aplicada a cada elemento de matriz de entrada e agrupa os elementos usando a condição de agrupamento.

Valor devolvido

Um objeto.

Exemplos

O exemplo a seguir mostra como usar a groupBy função.

{
  "$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)))]"
    }
  }
}

A saída do exemplo anterior mostra os cães com cinco anos ou mais:

Nome	Tipo	valor
outObject	Object	{"f":["foo"],"b":["bar","baz"]}

outObject mostra um objeto que agrupa os elementos da matriz por suas primeiras letras.

map

map(inputArray, lambda function)

Aplica uma função de mapeamento personalizada a cada elemento de uma matriz.

No Bicep, use a função de mapa .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz a ser mapeada.
Função lambda	Sim	expressão	A função lambda aplicada a cada elemento de matriz de entrada, a fim de gerar a matriz de saída.

Valor devolvido

Uma matriz.

Exemplo

O exemplo a seguir mostra como usar a map função.

{
  "$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)))]"
    }
  }
}

A saída do exemplo anterior é:

Nome	Tipo	valor
dogNomes	Matriz	["Evie","Casper","Indy","Kira"]
sayOi	Matriz	["Olá Evie!","Olá Casper!","Olá Indy!","Olá Kira!"]
mapArray	Matriz	[{"i":0,"cão":"Evie","saudação":"Ahoy, Evie!"},{"i":1,"cão":"Casper","saudação":"Ahoy, Casper!"},{"i":2,"cão":"Indy","saudação":"Ahoy, Indy!"},{"i":3,"cão":"Kira","saudação":"Ahoy, Kira!"}]
mapArrayIndex	Matriz	[{"index":0,"val":"Evie"},{"index":1,"val":"Casper"},{"index":2,"val":"Indy"},{"index":3,"val":"Kira"}]

dogNames mostra os nomes dos cães a partir da matriz de objetos; sayHi concatena "Olá" e cada um dos nomes dos cães; mapArray e mapArrayIndex criam outras duas matrizes de objetos.

mapValores

mapValues(inputObject, lambda expression)

Cria um objeto a partir de um objeto de entrada, usando uma expressão lambda para mapear valores.

No Bicep, use a função mapValues .

Parâmetros

Parâmetro	Necessário	Type	Description
inputObject	Sim	objeto	O objeto a ser mapeado.
expressão lambda	Sim	expressão	A expressão lambda usada para mapear os valores.

Valor devolvido

Um objeto.

Exemplo

O exemplo a seguir mostra como usar a mapValues função.

{
  "$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'))))]"
    }
  }
}

A saída do exemplo anterior é:

Nome	Tipo	valor
mapObject	Object	{foo: 'FOO', bar: 'BAR'}

mapObject cria outro objeto com os valores em maiúsculas.

reduzir

reduce(inputArray, initialValue, lambda function)

Reduz uma matriz com uma função de redução personalizada.

No Bicep, utilize a função redutora .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz a ser reduzida.
initialValue	Sim	qualquer	Valor inicial.
Função lambda	Sim	expressão	A função lambda usada para agregar o valor atual e o próximo valor.

Valor devolvido

Qualquer.

Exemplo

Os exemplos a seguir mostram como usar a reduce função.

{
  "$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'))))]"
    }
  }
}

A saída do exemplo anterior é:

Nome	Tipo	valor
totalIdade	número inteiro	18
totalAgeAdd1	número inteiro	19
ímparIdade	número inteiro	7

totalAge soma as idades dos cães; totalAgeAdd1 tem um valor inicial de 1 e adiciona todas as idades dos cães aos valores iniciais. oddAge soma as idades dos cães que estão localizados em índices pares, especificamente 5 (Evie) e 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'))))]"
    }
  }
}

A saída do exemplo anterior é:

Nome	Tipo	valor
reduceObjectUnion	objeto	{"foo":123,"bar":456,"baz":789}

A função union retorna um único objeto com todos os elementos dos parâmetros. A chamada de função unifica os pares de valor-chave dos objetos em um novo objeto.

sort

sort(inputArray, lambda function)

Classifica uma matriz com uma função de classificação personalizada.

No Bicep, use a função de classificação .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz a ser classificada.
Função lambda	Sim	expressão	A função lambda usada para comparar dois elementos de matriz para ordenação. Se true, o segundo elemento será ordenado após o primeiro na matriz de saída.

Valor devolvido

Uma matriz.

Exemplo

O exemplo a seguir mostra como usar a sort função.

{
  "$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)))]"
    }
  }
}

A saída do exemplo anterior classifica os objetos de cão do mais novo para o mais velho:

Nome	Tipo	valor
cãesByAge	Matriz	[{"nome":"Indy","idade":2,"interesses":["Manteiga"]},{"nome":"Casper","idade":3,"interesses":["Outros cães"]},{"nome":"Evie","idade":5,"interesses":["Bola","Frisbee"]},{"nome":"Kira","idade":8,"interesses":["Rubs"]}]

toObject

toObject(inputArray, lambda function, [lambda function])

Converte uma matriz em um objeto com uma função de chave personalizada e uma função de valor personalizado opcional. Consulte os itens sobre como converter um objeto em uma matriz.

No Bicep, use a função toObject .

Parâmetros

Parâmetro	Necessário	Type	Description
inputArray	Sim	matriz	A matriz usada para criar um objeto.
Função lambda	Sim	expressão	A função lambda usada para fornecer o predicado de chave.
Função lambda	Não	expressão	A função lambda usada para fornecer o predicado de valor.

Valor devolvido

Um objeto.

Exemplo

O exemplo a seguir mostra como usar a toObject função com os dois parâmetros necessários:

{
  "$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))]"
    }
  }
}

O exemplo anterior gera um objeto baseado em uma matriz.

Nome	Tipo	valor
cãesObjeto	Object	{"Evie":{"name":"Evie","age":5,"interest":["Ball","Frisbee"]},"Casper":{"name":"Casper","age":3,"interest":["Other dogs"]},"Indy":{"name":"Indy","age":2,"interest":["Butter"]},"Kira":{"name":"Kira","age":8,"interest":["Rubs"]}}

A função a seguir toObject com o terceiro parâmetro fornece a mesma saída.

"outputs": {
  "dogsObject": {
    "type": "object",
    "value": "[toObject(variables('dogs'), lambda('entry', lambdaVariables('entry').name), lambda('entry', lambdaVariables('entry')))]"
  }
}

O exemplo a seguir mostra como usar a toObject função com três 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))]"
    }
  }
}

O exemplo anterior gera um objeto baseado em uma matriz.

Nome	Tipo	valor
cãesObjeto	Object	{"Evie":{"age":5,"interesses":["Bola","Frisbee"]},"Casper":{"age":3,"interesses":["Outros cães"]},"Indy":{"age":2,"interesses":["Butter"]},"Kira":{"age":8,"interesses":["Rubs"]}}

Próximos passos

Consulte Funções de modelo - matrizes para obter mais funções de modelo relacionadas a matrizes.

Partilhar via

Funções do Lambda para modelos ARM

Limitações

filtrar

Parâmetros

Valor devolvido

Exemplos

groupBy

Parâmetros

Valor devolvido

Exemplos

map

Parâmetros

Valor devolvido

Exemplo

mapValores

Parâmetros

Valor devolvido

Exemplo

reduzir

Parâmetros

Valor devolvido

Exemplo

sort

Parâmetros

Valor devolvido

Exemplo

toObject

Parâmetros

Valor devolvido

Exemplo

Próximos passos

Comentários

Recursos adicionais