Freigeben über

Lambdafunktionen für Bicep

  • Artikel

In diesem Artikel werden die Lambdafunktionen beschrieben, die in Bicep verwendet werden können. Lambdaausdrücke (oder 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 variable> => <expression>

Hinweis

Die Lambdafunktionen werden nur in der Bicep CLI Version 0.10.X oder höher unterstützt.

Begrenzungen

Für Bicep-Lambdafunktionen 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 im 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 expression)

Filtert ein Array mit einer benutzerdefinierten Filterfunktion.

Namespace: sys.

Parameter

Parameter Erforderlich Type BESCHREIBUNG
inputArray Ja array Das zu filternde Array.
Lambdaausdruck Ja expression Die Lambdafunktion wird auf jedes Element im Eingabearray angewandt. Wenn das Ergebnis TRUE ist, wird das Element in das Ausgabearray eingeschlossen. Andernfalls wird das Element verworfen.

Rückgabewert

Ein -Array.

Beispiele

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

var dogs = [
  {
    name: 'Evie'
    age: 5
    interests: ['Ball', 'Frisbee']
  }
  {
    name: 'Casper'
    age: 3
    interests: ['Other dogs']
  }
  {
    name: 'Indy'
    age: 2
    interests: ['Butter']
  }
  {
    name: 'Cira'
    age: 8
    interests: ['Rubs']
  }
]

output oldDogs array = filter(dogs, dog => dog.age >=5)
output dogNameIndex array = filter(dogs, (val, i) => i < 2 && substring(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.

var itemForLoop = [for item in range(0, 10): item]

output filteredLoop array = filter(itemForLoop, i => i > 5)
output isEven array = filter(range(0, 10), i => 0 == i % 2)

Die Ausgaben aus dem vorherigen Beispiel:

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.

Namespace: sys.

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.

var inputArray = ['foo', 'bar', 'baz']

output outObject object = groupBy(inputArray, x => substring(x, 0, 1))

Die Ausgabe des vorherigen Beispiels lautet wie folgt:

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 expression)

Wendet eine benutzerdefinierte Zuordnungsfunktion auf jedes Element eines Arrays an.

Namespace: sys.

Parameter

Parameter Erforderlich Type BESCHREIBUNG
inputArray Ja array Das Array, das zugeordnet werden soll.
Lambdaausdruck 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.

var 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']
  }
]

output dogNames array = map(dogs, dog => dog.name)
output sayHi array = map(dogs, dog => 'Hello ${dog.name}!')
output mapArray array = map(range(0, length(dogs)), i => {
  i: i
  dog: dogs[i].name
  greeting: 'Ahoy, ${dogs[i].name}!'
})
output mapArrayIndex array = map(dogs, (x, i) => { index: i, val: x.name})

Die Ausgaben aus dem vorherigen Beispiel sind:

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.

Namespace: sys.

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.

var inputObject = { foo: 'foo', bar: 'bar' }

output mapObject object = mapValues(inputObject, val => toUpper(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 expression)

Reduziert ein Array mit einer benutzerdefinierten reduce-Funktion.

Namespace: sys.

Parameter

Parameter Erforderlich Type BESCHREIBUNG
inputArray Ja array Das Array, das reduziert werden soll.
initialValue Ja any Anfangswert.
Lambdaausdruck 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.

var 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']
  }
]
var ages = map(dogs, dog => dog.age)
output totalAge int = reduce(ages, 0, (cur, next) => cur + next)
output totalAgeAdd1 int = reduce(ages, 1, (cur, next) => cur + next)
output oddAge int = reduce(ages, 0, (cur, next, i) => (i % 2 == 0) ? cur + next : cur)

Die Ausgaben aus dem vorherigen Beispiel sind:

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).

output reduceObjectUnion object = reduce([
  { foo: 123 }
  { bar: 456 }
  { baz: 789 }
], {}, (cur, next) => union(cur, 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 expression)

Sortiert ein Array mit einer benutzerdefinierten Sortierfunktion.

Namespace: sys.

Parameter

Parameter Erforderlich Type BESCHREIBUNG
inputArray Ja array Das Array, das sortiert werden soll.
Lambdaausdruck 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.

var 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']
  }
]

output dogsByAge array = sort(dogs, (a, b) => a.age < 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 expression, [lambda expression])

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.

Namespace: sys.

Parameter

Parameter Erforderlich Type BESCHREIBUNG
inputArray Ja array Das Array, das zum Erstellen eines Objekts verwendet wird.
Lambdaausdruck Ja expression Der Lambdaausdruck, der zum Bereitstellen des Schlüsselprädikats verwendet wird.
Lambdaausdruck Nein expression Der Lambdaausdruck, der 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:

var 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' ]
  }
]

output dogsObject object = toObject(dogs, entry => 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.

output dogsObject object = toObject(dogs, entry => entry.name, entry => entry)

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

var 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' ]
    }
  }
]
output dogsObject object = toObject(dogs, entry => entry.name, entry => 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