Lambdafunktionen für ARM-Vorlagen

Artikel
05/29/2024

In diesem Artikel werden die Lambdafunktionen beschrieben, die in ARM-Vorlagen verwendet werden können. Lambdafunktionen sind im Wesentlichen Codeblöcke, die als Argument übergeben werden können. Sie können mehrere Parameter akzeptieren, sind aber auf eine einzige Codezeile beschränkt. In Bicep haben Lambdafunktionen dieses Format:

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

Tipp

Wir empfehlen Bicep, weil es dieselben Funktionen wie ARM-Vorlagen bietet und die Syntax einfacher zu verwenden ist. Weitere Informationen finden Sie unter Bereitstellungsfunktionen.

Einschränkungen

Für Lambdafunktionen in ARM-Vorlagen gelten folgende Einschränkungen:

Lambda-Ausdruck kann nur direkt als Funktionsargumente in diesen Funktionen angegeben werden: , , , , map(), mapValues(), reduce(), und sort()toObject(). groupBy()filter()
Die Verwendung von Lambdavariablen (die temporären Variablen, die in den Lambdafunktionen verwendet werden) beim Zugriff auf ein Ressourcen- oder Modularray wird derzeit nicht unterstützt.
Die Verwendung von Lambdavariablen innerhalb der listKeys-Funktion wird derzeit nicht unterstützt.
Die Verwendung von Lambdavariablen innerhalb der reference-Funktion wird derzeit nicht unterstützt.

filter

filter(inputArray, lambda function)

Filtert ein Array mit einer benutzerdefinierten Filterfunktion.

Verwenden Sie in Bicep die filter-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das zu filternde Array.
Lambdafunktion	Ja	expression	Die Lambdafunktion, der auf jedes Element im Eingabearray angewandt wird. Falls „false“, wird das Element aus dem Ausgabearray herausgefiltert.

Rückgabewert

Ein -Array.

Beispiele

In den folgenden Beispielen wird die Verwendung der filter-Funktion gezeigt.

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

Die Ausgaben aus dem vorherigen Beispiel:

Name	type	Wert
oldDogs	Array	[{"name":"Evie","age":5,"interests":["Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}]
dogNameIndex	Array	[{"name":"Casper","age":3,"interessen":["Andere Hunde"]}]

oldDogs listet die Hunde auf, die fünf oder älter sind; dogNameIndex identifiziert die Hunde, deren Indexnummer kleiner als zwei ist und deren Name mit dem Buchstaben "C" beginnt.

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

Die Ausgabe des vorherigen Beispiels lautet wie folgt:

Name	type	Wert
filteredLoop	Array	[6, 7, 8, 9]
isEven	Array	[0, 2, 4, 6, 8]

filterdLoop zeigt die Zahlen in einem Array an, die größer als 5 sind, und isEven zeigt die geraden Zahlen im Array an.

groupBy

groupBy(inputArray, lambda expression)

Erstellt mithilfe einer Gruppierungsbedingung ein Objekt mit Arraywerten aus einem Array.

Verwenden Sie in Bicep die groupBy-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das Array für die Gruppierung.
Lambdaausdruck	Ja	expression	Der Lambdaausdruck wird auf jedes Eingabearrayelement angewandt und gruppiert die Elemente anhand der Gruppierungsbedingung.

Rückgabewert

Ein -Objekt.

Beispiele

Das folgende Beispiel zeigt die Verwendung der Funktion 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)))]"
    }
  }
}

Die Ausgabe des vorherigen Beispiels enthält die Hunde, die fünf Jahre oder älter sind:

Name	type	Wert
outObject	Objekt	{"f":["foo"],"b":["bar","baz"]}

outObject zeigt ein Objekt, das die Arrayelemente nach ihren ersten Buchstaben gruppiert.

Karte

map(inputArray, lambda function)

Wendet eine benutzerdefinierte Zuordnungsfunktion auf jedes Element eines Arrays an.

Verwenden Sie in Bicep die map-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das Array, das zugeordnet werden soll.
Lambdafunktion	Ja	expression	Die Lambdafunktion, die auf jedes Element im Eingabearray angewandt wird, um das Ausgabearray zu generieren.

Rückgabewert

Ein -Array.

Beispiel

Das folgende Beispiel zeigt die Verwendung der Funktion 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)))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
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 zeigt die Hundenamen aus dem Objektarray; sayHi verkettet "Hello" und jeden der Hundenamen; mapArray und mapArrayIndex erstellen weitere zwei Arrays von Objekten.

mapValues

mapValues(inputObject, lambda expression)

Erstellt mithilfe eines Lambdaausdrucks zum Zuordnen von Werten ein Objekt aus einem Eingabeobjekt.

Verwenden Sie in Bicep die mapValues-Funktion.

Parameter

Parameter	Erforderlich	Type	Beschreibung
inputObject	Ja	Objekt	Das zuzuordnende Objekt.
Lambdaausdruck	Ja	expression	Der Lambdaausdruck, der zum Zuordnen der Werte verwendet wird.

Rückgabewert

Ein Objekt.

Beispiel

Das folgende Beispiel zeigt die Verwendung der Funktion 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'))))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
mapObject	Objekt	{foo: 'FOO', bar: 'BAR'}

mapObject erstellt ein weiteres Objekt mit den Werten in Großbuchstaben.

reduce

reduce(inputArray, initialValue, lambda function)

Reduziert ein Array mit einer benutzerdefinierten reduce-Funktion.

Verwenden Sie in Bicep die reduce-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das Array, das reduziert werden soll.
initialValue	Ja	any	Anfangswert.
Lambdafunktion	Ja	expression	Die Lambdafunktion, die zum Aggregieren des aktuellen Werts und des nächsten Werts verwendet wird.

Rückgabewert

Alle.

Beispiel

In den folgenden Beispielen wird die Verwendung der reduce-Funktion gezeigt.

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

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
totalAge	INT	18
totalAgeAdd1	INT	19
oddAge	int	7

totalAge addiert das Alter der Hunde, totalAgeAdd1 weist einen Anfangswert von 1 auf und addiert das Alter aller Hunde mit den Anfangswerten. OddAge summiert das Alter von Hunden, die sich in geraden Indizes befinden, insbesondere 5 (Evie) und 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'))))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
reduceObjectUnion	Objekt (object)	{"foo":123,"bar":456,"baz":789}

Die union-Funktion gibt ein einzelnes Objekt mit allen Elementen aus den Parametern zurück. Durch den Funktionsaufruf werden die Schlüssel-Wert-Paare der Objekte in einem neuen Objekt vereinigt.

sort

sort(inputArray, lambda function)

Sortiert ein Array mit einer benutzerdefinierten Sortierfunktion.

Verwenden Sie in Bicep die sort-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das Array, das sortiert werden soll.
Lambdafunktion	Ja	expression	Die Lambdafunktion, mit der zwei Arrayelemente für die Sortierung verglichen werden. Bei TRUE wird das zweite Element im Ausgabearray hinter dem ersten Element einsortiert.

Rückgabewert

Ein -Array.

Beispiel

Das folgende Beispiel zeigt die Verwendung der Funktion 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)))]"
    }
  }
}

In der Ausgabe aus dem vorherigen Beispiel sind die dog-Objekte vom jüngsten zum ältesten Hund sortiert:

Name	type	Wert
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])

Konvertiert ein Array in ein Objekt mit einer benutzerdefinierten Schlüsselfunktion und optionaler benutzerdefinierter Wertfunktion. Weitere Informationen zum Konvertieren eines Objekts in ein Array finden Sie unter Elemente.

Verwenden Sie in Bicep die toObject-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Ja	array	Das Array, das zum Erstellen eines Objekts verwendet wird.
Lambdafunktion	Ja	expression	Die Lambdafunktion, die zum Bereitstellen des Schlüsselprädikats verwendet wird.
Lambdafunktion	Nein	expression	Die Lambdafunktion, die zum Bereitstellen des Wertprädikats verwendet wird.

Rückgabewert

Ein Objekt.

Beispiel

Im folgenden Beispiel wird gezeigt, wie die toObject-Funktion mit den beiden erforderlichen Parametern verwendet wird:

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

Im vorherigen Beispiel wird ein Objekt basierend auf einem Array generiert.

Name	type	Wert
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"]}}

Die folgende toObject-Funktion mit dem dritten Parameter stellt die gleiche Ausgabe bereit.

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

Im folgenden Beispiel wird gezeigt, wie die toObject-Funktion mit drei Parametern verwendet wird.

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

Im vorherigen Beispiel wird ein Objekt basierend auf einem Array generiert.

Name	type	Wert
dogsObject	Object	{"Evie":{"age":5,"interests":["Ball","Frisbee"]},"Casper":{"age":3,"interests":["Other dogs"]},"Indy":{"age":2,"interests":["Butter"]},"Kira":{"age":8,"interests":["Rubs"]}}

Nächste Schritte

Weitere arraybezogene Vorlagenfunktionen finden Sie unter Vorlagenfunktionen – Arrays.

Freigeben über

Lambdafunktionen für ARM-Vorlagen

Einschränkungen

filter

Parameter

Rückgabewert

Beispiele

groupBy

Parameter

Rückgabewert

Beispiele

Karte

Parameter

Rückgabewert

Beispiel

mapValues

Parameter

Rückgabewert

Beispiel

reduce

Parameter

Rückgabewert

Beispiel

sort

Parameter

Rückgabewert

Beispiel

toObject

Parameter

Rückgabewert

Beispiel

Nächste Schritte

Feedback

Zusätzliche Ressourcen