Funções lambda para modelos do ARM

Artigo
05/29/2024

Este artigo descreve as funções lambda a serem usadas nos modelos do ARM. As funções lambda são essencialmente blocos de códigos que podem ser passados como argumento. Eles podem usar 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>)

Dica

Recomendamos o Bicep porque ele oferece as mesmas funcionalidades que os modelos do ARM e a sintaxe é mais fácil de usar. Para saber mais, confira as funções de implantação.

Limitações

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

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

filter

filter(inputArray, lambda function)

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

No Bicep, use a função filter.

Parâmetros

Parâmetro	Obrigatório	Type	Descrição
inputArray	Sim	matriz	A matriz a filtrar.
função lambda	Sim	expressão	A função lambda aplicada a cada elemento matriz de entrada. Se for falso, o item será filtrado para fora da matriz de saída.

Retornar valor

Uma matriz .

Exemplos

Os exemplos a seguir mostram como usar a função 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'))))]"
    }
  }
}

As saídas do exemplo anterior:

Nome	Tipo	Valor
oldDogs	Array	[{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}]
dogNameIndex	Array	[{"nome":"Casper","idade":3,"interesses":["Outros cães"]}]

oldDogs lista os cães que têm cinco anos ou mais; dogNameIndex identifica os cães cujo número de índice é menor que 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	Array	[6, 7, 8, 9]
isEven	Array	[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)

Criar um objeto com valores de matriz a partir de uma matriz, usando uma condição de agrupamento.

No Bicep, use a função groupBy.

Parâmetros

Parâmetro	Obrigatório	Type	Descrição
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 retornado

Um objeto .

Exemplos

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

A saída do exemplo anterior mostra os cachorros com cinco anos ou mais:

Nome	Tipo	Valor
outObject	Objeto	{"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 map.

Parâmetros

Parâmetro	Obrigatório	Type	Descrição
inputArray	Sim	matriz	A matriz a ser mapeada.
função lambda	Sim	expressão	A função lambda aplicada a cada elemento matriz de entrada, para gerar a matriz de saída.

Retornar valor

Uma matriz .

Exemplo

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

O resultado do exemplo anterior é:

Nome	Tipo	Valor
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	Array	[{"index":0,"val":"Evie"},{"index":1,"val":"Casper"},{"index":2,"val":"Indy"},{"index":3,"val":"Kira"}]

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

mapValues

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	Obrigatório	Type	Descrição
inputObject	Yes	objeto	O objeto a ser mapeado.
expressão lambda	Sim	expressão	A expressão lambda usada para mapear os valores.

Valor retornado

Um objeto.

Exemplo

O exemplo a seguir mostra como usar a função 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'))))]"
    }
  }
}

O resultado do exemplo anterior é:

Nome	Tipo	Valor
mapObject	Objeto	{foo: 'FOO', bar: 'BAR'}

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

reduce

reduce(inputArray, initialValue, lambda function)

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

No Bicep, use a função reduce.

Parâmetros

Parâmetro	Obrigatório	Type	Descrição
inputArray	Sim	matriz	A matriz a ser reduzida.
initialValue	Sim	any	Valor inicial.
função lambda	Sim	expressão	A função lambda usada para agregar o valor atual e o próximo valor.

Retornar valor

Qualquer um.

Exemplo

Os exemplos a seguir mostram como usar a função 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'))))]"
    }
  }
}

O resultado do exemplo anterior é:

Nome	Tipo	Valor
totalAge	INT	18
totalAgeAdd1	INT	19
Idade ímpar	int	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'))))]"
    }
  }
}

O resultado do exemplo anterior é:

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

A função união retorna um único objeto com todos os elementos dos parâmetros. A chamada de função sindicaliza os pares de valor de 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 sort.

Parâmetros

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

Retornar valor

Uma matriz .

Exemplo

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

A saída do exemplo anterior classifica os objetos de cachorro dos mais jovens para os mais antigos:

Nome	Tipo	Valor
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])

Converte uma matriz em um objeto com uma função de chave personalizada e uma função de valor personalizado opcional. Confira os itens sobre a conversão de um objeto em uma matriz.

No Bicep, use a função toObject .

Parâmetros

Parâmetro	Obrigatório	Type	Descrição
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 da chave.
função lambda	Não	expressão	A função lambda usada para fornecer o predicado do valor.

Retornar valor

Um objeto.

Exemplo

O exemplo a seguir mostra como usar a função toObject com os dois parâmetros obrigató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 com base numa matriz.

Nome	Tipo	Valor
dogsObject	Objeto	{"Evie":{"nome":"Evie","idade":5,"interesses":["Bola","Frisbee"]},"Casper":{"nome":"Casper","idade":3,"interesses":["Outros cães"]},"Indy":{"nome":"Indy","idade":2,"interesses":["Borboleta"]},"Kira":{"nome":"Kira","idade":8,"interesses":["Borrachas"]}}

A seguinte função 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 função toObject 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 com base numa matriz.

Nome	Tipo	Valor
dogsObject	Objeto	{"Evie":{"idade":5,"interesses":["Bola","Frisbee"]},"Casper":{"idade":3,"interesses":["Outros cães"]},"Indy":{"idade":2,"interesses":["Borboleta"]},"Kira":{"idade":8,"interesses":["Borrachas"]}}

Próximas etapas

Consulte Funções de modelo – matrizes para mais funções de modelo relacionadas à matriz.

Compartilhar via

Funções lambda para modelos do ARM

Limitações

filter

Parâmetros

Retornar valor

Exemplos

groupBy

Parâmetros

Valor retornado

Exemplos

map

Parâmetros

Retornar valor

Exemplo

mapValues

Parâmetros

Valor retornado

Exemplo

reduce

Parâmetros

Retornar valor

Exemplo

sort

Parâmetros

Retornar valor

Exemplo

toObject

Parâmetros

Retornar valor

Exemplo

Próximas etapas

Comentários

Recursos adicionais