Udostępnij za pośrednictwem


Funkcje lambda dla szablonów usługi ARM

W tym artykule opisano funkcje lambda do użycia w szablonach usługi ARM. Funkcje lambda to zasadniczo bloki kodu, które można przekazać jako argument. Mogą przyjmować wiele parametrów, ale są ograniczone do jednego wiersza kodu. W wyrażeniu lambda w języku Bicep ma następujący format:

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

Napiwek

Zalecamy Bicep , ponieważ oferuje te same możliwości co szablony usługi ARM, a składnia jest łatwiejsza w użyciu. Aby dowiedzieć się więcej, zobacz funkcje wdrażania .

Ograniczenia

Funkcja lambda szablonu usługi ARM ma następujące ograniczenia:

  • Wyrażenie lambda można określić tylko bezpośrednio jako argumenty funkcji w tych funkcjach: filter(), , , mapValues()groupBy()reduce()map(), sort(), i .toObject()
  • Używanie zmiennych lambda (zmiennych tymczasowych używanych w funkcjach lambda) w dostępie do zasobów lub tablicy modułów nie jest obecnie obsługiwane.
  • Używanie zmiennych lambda wewnątrz listKeys funkcji nie jest obecnie obsługiwane.
  • Używanie zmiennych lambda wewnątrz funkcji referencyjnej nie jest obecnie obsługiwane.

filtr

filter(inputArray, lambda function)

Filtruje tablicę za pomocą niestandardowej funkcji filtrowania.

W Bicep użyj funkcji filter .

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica do filtrowania.
lambda, funkcja Tak wyrażenie Funkcja lambda zastosowana do każdego elementu tablicy wejściowej. Jeśli wartość false, element jest filtrowany z tablicy wyjściowej.

Wartość zwracana

Tablicy.

Przykłady

W poniższych przykładach pokazano, jak używać filter funkcji.

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

Dane wyjściowe z poprzedniego przykładu:

Nazwisko Typ Wartość
oldDogs Tablica [{"name":"Evie","age":5,"interests"::"Ball","Frisbee"]},{"name":"Kira","age":8,"interests":["Rubs"]}]
dogNameIndex Tablica [{"name":"Casper","age":3,"interests":["Other dogs"]}]

oldDogs wymienia psy, które są pięć lub starsze; dogNameIndex identyfikuje psy, których numer indeksu jest mniejszy niż dwa i którego nazwa zaczyna się literą "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))))]"
    }
  }
}

Dane wyjściowe z poprzedniego przykładu:

Nazwisko Typ Wartość
filteredLoop Tablica [6, 7, 8, 9]
Iseven Tablica [0, 2, 4, 6, 8]

filterdLoop pokazuje liczby w tablicy, które są większe niż 5; i isEven pokazuje liczby parzystych w tablicy.

Groupby

groupBy(inputArray, lambda expression)

Tworzy obiekt z wartościami tablicy z tablicy przy użyciu warunku grupowania.

W Bicep użyj funkcji groupBy .

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica do grupowania.
wyrażenie lambda Tak wyrażenie Wyrażenie lambda jest stosowane do każdego elementu tablicy wejściowej i grupuje elementy przy użyciu warunku grupowania.

Wartość zwracana

Obiekt .

Przykłady

W poniższym przykładzie pokazano, jak używać groupBy funkcji.

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

Dane wyjściowe z poprzedniego przykładu pokazują psy, które są pięć lub starsze:

Nazwisko Typ Wartość
outObject Objekt {"f":["foo"],"b":["bar","baz"]}

obiekt outObject przedstawia obiekt, który grupuje elementy tablicy według pierwszych liter.

map

map(inputArray, lambda function)

Stosuje funkcję mapowania niestandardowego do każdego elementu tablicy.

W Bicep użyj funkcji mapowania.

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica do mapowania.
lambda, funkcja Tak wyrażenie Funkcja lambda zastosowana do każdego elementu tablicy wejściowej w celu wygenerowania tablicy wyjściowej.

Wartość zwracana

Tablicy.

Przykład

W poniższym przykładzie pokazano, jak używać map funkcji.

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

Dane wyjściowe z poprzedniego przykładu to:

Nazwisko Typ Wartość
dogNames Tablica ["Evie","Casper","Indy","Kira"]
sayHi Tablica ["Hello Evie!","Hello Casper!","Hello Indy!","Hello Kira!"]
mapArray Tablica [{"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 Tablica [{"index":0,"val":"Evie"},{"index":1,"val":"Casper"},{"index":2,"val":"Indy"},{"index":3,"val":"Kira"}]

dogNames pokazuje nazwy psów z tablicy obiektów; sayHi łączy "Hello" i każde z imion psów; mapArray i mapArrayIndex tworzą kolejne dwie tablice obiektów.

mapValues

mapValues(inputObject, lambda expression)

Tworzy obiekt z obiektu wejściowego przy użyciu wyrażenia lambda do mapowania wartości.

W Bicep użyj funkcji mapValues .

Parametry

Parametr Wymagania Type Opis
inputObject Tak obiekt Obiekt do mapowania.
wyrażenie lambda Tak wyrażenie Wyrażenie lambda używane do mapowania wartości.

Wartość zwracana

Obiekt .

Przykład

W poniższym przykładzie pokazano, jak używać mapValues funkcji.

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

Dane wyjściowe z poprzedniego przykładu to:

Nazwisko Typ Wartość
mapObject Objekt {foo: 'FOO', bar: 'BAR'}

obiekt mapObject tworzy inny obiekt z wartościami w wielkim przypadku.

Zmniejszyć

reduce(inputArray, initialValue, lambda function)

Zmniejsza tablicę za pomocą niestandardowej funkcji redukcji.

W Bicep użyj funkcji redukcji.

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica do zmniejszenia.
initialValue Tak dowolny Wartość początkowa.
lambda, funkcja Tak wyrażenie Funkcja lambda używana do agregowania bieżącej wartości i następnej wartości.

Wartość zwracana

Wszelki.

Przykład

W poniższych przykładach pokazano, jak używać reduce funkcji.

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

Dane wyjściowe z poprzedniego przykładu to:

Nazwisko Typ Wartość
totalAge int 18
totalAgeAdd1 int 19
oddAge int 7

totalAge sumuje wiek psów; totalAgeAdd1 ma początkową wartość 1 i dodaje wszystkie grupy wiekowe psów do początkowych wartości. oddAge sumuje wiek psów, które znajdują się w indeksach parzysłych, w szczególności 5 (Evie) i 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'))))]"
    }
  }
}

Dane wyjściowe z poprzedniego przykładu to:

Nazwisko Typ Wartość
reduceObjectUnion obiekt {"foo":123,"bar":456,"baz":789}

Funkcja union zwraca pojedynczy obiekt ze wszystkimi elementami z parametrów. Wywołanie funkcji łączy pary wartości klucza obiektów w nowy obiekt.

sort

sort(inputArray, lambda function)

Sortuje tablicę za pomocą niestandardowej funkcji sortowania.

W Bicep użyj funkcji sortowania.

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica do sortowania.
lambda, funkcja Tak wyrażenie Funkcja lambda używana do porównywania dwóch elementów tablicy do porządkowania. Jeśli wartość true, drugi element zostanie uporządkowany po pierwszym w tablicy wyjściowej.

Wartość zwracana

Tablicy.

Przykład

W poniższym przykładzie pokazano, jak używać sort funkcji.

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

Dane wyjściowe z poprzedniego przykładu sortuje obiekty psów od najmłodszych do najstarszych:

Nazwisko Typ Wartość
dogsByAge Tablica [{"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])

Konwertuje tablicę na obiekt z funkcją klucza niestandardowego i opcjonalną funkcją wartości niestandardowej. Zobacz elementy dotyczące konwertowania obiektu na tablicę.

W Bicep użyj funkcji toObject .

Parametry

Parametr Wymagania Type Opis
inputArray Tak tablica Tablica używana do tworzenia obiektu.
lambda, funkcja Tak wyrażenie Funkcja lambda używana do zapewnienia predykatu klucza.
lambda, funkcja Nie. wyrażenie Funkcja lambda używana do podawania predykatu wartości.

Wartość zwracana

Obiekt .

Przykład

W poniższym przykładzie pokazano, jak używać toObject funkcji z dwoma wymaganymi parametrami:

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

Powyższy przykład generuje obiekt na podstawie tablicy.

Nazwisko Typ Wartość
dogsObject Objekt {"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"]}}

Poniższa toObject funkcja z trzecim parametrem udostępnia te same dane wyjściowe.

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

W poniższym przykładzie pokazano, jak używać toObject funkcji z trzema parametrami.

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

Powyższy przykład generuje obiekt na podstawie tablicy.

Nazwisko Typ Wartość
dogsObject Objekt {"Evie":{"age"::5,"interests":["Ball","Frisbee"]},"Casper":{"age":3,"interests":["Other dogs"]},"Indy":{"age":2,"interests":["Butter"]},"Kira":{"age":8,"interests":["Rubs"]}}

Następne kroki