Partilhar via


Funções do Lambda para modelos ARM

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