Funkcje obiektów dla szablonów usługi ARM
Usługa Resource Manager udostępnia kilka funkcji do pracy z obiektami w szablonie usługi Azure Resource Manager (szablon usługi ARM):
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 obiektów .
zawiera
contains(container, itemToFind)
Sprawdza, czy tablica zawiera wartość, obiekt zawiera klucz, czy ciąg zawiera podciąg. Porównanie ciągów uwzględnia wielkość liter. Jednak podczas testowania, czy obiekt zawiera klucz, porównanie jest bez uwzględniania wielkości liter.
W pliku Bicep użyj funkcji contains .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| kontener | Tak | tablica, obiekt lub ciąg | Wartość zawierająca wartość do znalezienia. |
| itemToFind | Tak | ciąg lub int | Wartość do znalezienia. |
Wartość zwracana
Wartość True , jeśli element zostanie znaleziony; w przeciwnym razie wartość False.
Przykład
W poniższym przykładzie pokazano, jak używać z contains różnymi typami:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringToTest": {
"type": "string",
"defaultValue": "OneTwoThree"
},
"objectToTest": {
"type": "object",
"defaultValue": {
"one": "a",
"two": "b",
"three": "c"
}
},
"arrayToTest": {
"type": "array",
"defaultValue": [ "one", "two", "three" ]
}
},
"resources": [
],
"outputs": {
"stringTrue": {
"type": "bool",
"value": "[contains(parameters('stringToTest'), 'e')]"
},
"stringFalse": {
"type": "bool",
"value": "[contains(parameters('stringToTest'), 'z')]"
},
"objectTrue": {
"type": "bool",
"value": "[contains(parameters('objectToTest'), 'one')]"
},
"objectFalse": {
"type": "bool",
"value": "[contains(parameters('objectToTest'), 'a')]"
},
"arrayTrue": {
"type": "bool",
"value": "[contains(parameters('arrayToTest'), 'three')]"
},
"arrayFalse": {
"type": "bool",
"value": "[contains(parameters('arrayToTest'), 'four')]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| stringTrue | Bool | Prawda |
| stringFalse | Bool | Fałsz |
| objectTrue | Bool | Prawda |
| objectFalse | Bool | Fałsz |
| arrayTrue | Bool | Prawda |
| arrayFalse | Bool | Fałsz |
Createobject
createObject(key1, value1, key2, value2, ...)
Tworzy obiekt na podstawie kluczy i wartości.
Funkcja nie jest obsługiwana createObject przez Bicep. Skonstruuj obiekt przy użyciu polecenia {}. Zobacz Obiekty.
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| klucz1 | Nie. | string | Nazwa klucza. |
| wartość1 | Nie. | int, wartość logiczna, ciąg, obiekt lub tablica | Wartość klucza. |
| więcej kluczy | Nie. | string | Więcej nazw kluczy. |
| więcej wartości | Nie. | int, wartość logiczna, ciąg, obiekt lub tablica | Więcej wartości dla kluczy. |
Funkcja akceptuje tylko parzystą liczbę parametrów. Każdy klucz musi mieć zgodną wartość.
Wartość zwracana
Obiekt z każdą parą klucz i wartość.
Przykład
Poniższy przykład tworzy obiekt z różnych typów wartości.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [
],
"outputs": {
"newObject": {
"type": "object",
"value": "[createObject('intProp', 1, 'stringProp', 'abc', 'boolProp', true(), 'arrayProp', createArray('a', 'b', 'c'), 'objectProp', createObject('key1', 'value1'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to obiekt o nazwie newObject o następującej wartości:
{
"intProp": 1,
"stringProp": "abc",
"boolProp": true,
"arrayProp": ["a", "b", "c"],
"objectProp": {"key1": "value1"}
}
empty
empty(itemToTest)
Określa, czy tablica, obiekt lub ciąg jest pusta.
W Bicep użyj funkcji empty .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| itemToTest | Tak | tablica, obiekt lub ciąg | Wartość do sprawdzenia, czy jest pusta. |
Wartość zwracana
Zwraca wartość True , jeśli wartość jest pusta; w przeciwnym razie wartość False.
Przykład
Poniższy przykład sprawdza, czy tablica, obiekt i ciąg są puste.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testArray": {
"type": "array",
"defaultValue": []
},
"testObject": {
"type": "object",
"defaultValue": {}
},
"testString": {
"type": "string",
"defaultValue": ""
}
},
"resources": [
],
"outputs": {
"arrayEmpty": {
"type": "bool",
"value": "[empty(parameters('testArray'))]"
},
"objectEmpty": {
"type": "bool",
"value": "[empty(parameters('testObject'))]"
},
"stringEmpty": {
"type": "bool",
"value": "[empty(parameters('testString'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| arrayEmpty | Bool | Prawda |
| objectEmpty | Bool | Prawda |
| stringEmpty | Bool | Prawda |
Przecięcia
intersection(arg1, arg2, arg3, ...)
Zwraca pojedynczą tablicę lub obiekt ze wspólnymi elementami z parametrów.
W Bicep użyj funkcji skrzyżowania.
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| arg1 | Tak | tablica lub obiekt | Pierwsza wartość używana do znajdowania typowych elementów. |
| arg2 | Tak | tablica lub obiekt | Druga wartość używana do znajdowania typowych elementów. |
| więcej argumentów | Nie. | tablica lub obiekt | Więcej wartości do użycia do znajdowania typowych elementów. |
Wartość zwracana
Tablica lub obiekt ze wspólnymi elementami.
Przykład
W poniższym przykładzie pokazano, jak używać z intersection tablicami i obiektami.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"firstObject": {
"type": "object",
"defaultValue": {
"one": "a",
"two": "b",
"three": "c"
}
},
"secondObject": {
"type": "object",
"defaultValue": {
"one": "a",
"two": "z",
"three": "c"
}
},
"firstArray": {
"type": "array",
"defaultValue": [ "one", "two", "three" ]
},
"secondArray": {
"type": "array",
"defaultValue": [ "two", "three" ]
}
},
"resources": [
],
"outputs": {
"objectOutput": {
"type": "object",
"value": "[intersection(parameters('firstObject'), parameters('secondObject'))]"
},
"arrayOutput": {
"type": "array",
"value": "[intersection(parameters('firstArray'), parameters('secondArray'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| objectOutput | Objekt | {"one": "a", "trzy": "c"} |
| arrayOutput | Tablica | ["dwa", "trzy"] |
elementy
items(object)
Konwertuje obiekt słownika na tablicę. Zobacz obiekt toObject dotyczący konwertowania tablicy na obiekt.
W Bicep użyj elementów.
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| obiekt | Tak | obiekt | Obiekt słownika do konwersji na tablicę. |
Wartość zwracana
Tablica obiektów dla przekonwertowanego słownika. Każdy obiekt w tablicy ma właściwość zawierającą key wartość klucza słownika. Każdy obiekt ma również właściwość zawierającą value właściwości obiektu.
Przykład
Poniższy przykład konwertuje obiekt słownika na tablicę. Dla każdego obiektu w tablicy tworzy nowy obiekt z zmodyfikowanymi wartościami.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"copy": [
{
"name": "modifiedListOfEntities",
"count": "[length(items(variables('entities')))]",
"input": {
"key": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].key]",
"fullName": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.displayName]",
"itemEnabled": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.enabled]"
}
}
],
"entities": {
"item002": {
"enabled": false,
"displayName": "Example item 2",
"number": 200
},
"item001": {
"enabled": true,
"displayName": "Example item 1",
"number": 300
}
}
},
"resources": [],
"outputs": {
"modifiedResult": {
"type": "array",
"value": "[variables('modifiedListOfEntities')]"
}
}
}
Powyższy przykład zwraca następujące dane:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
W poniższym przykładzie pokazano tablicę zwracaną z funkcji items.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"entities": {
"item002": {
"enabled": false,
"displayName": "Example item 2",
"number": 200
},
"item001": {
"enabled": true,
"displayName": "Example item 1",
"number": 300
}
},
"entitiesArray": "[items(variables('entities'))]"
},
"resources": [],
"outputs": {
"itemsResult": {
"type": "array",
"value": "[variables('entitiesArray')]"
}
}
}
Przykład zwraca następujące dane:
"itemsResult": {
"type": "Array",
"value": [
{
"key": "item001",
"value": {
"displayName": "Example item 1",
"enabled": true,
"number": 300
}
},
{
"key": "item002",
"value": {
"displayName": "Example item 2",
"enabled": false,
"number": 200
}
}
]
}
W formacie JSON obiekt jest nieurządkowaną kolekcją par klucz/wartość zero lub więcej. Kolejność może być różna w zależności od implementacji. Na przykład funkcja Bicep items() sortuje obiekty w kolejności alfabetycznej. W innych miejscach można zachować oryginalną kolejność. Ze względu na ten niedeterminizm należy unikać wprowadzania wszelkich założeń dotyczących porządkowania kluczy obiektów podczas pisania kodu, który wchodzi w interakcje z parametrami i danymi wyjściowymi wdrożeń.
json
json(arg1)
Konwertuje prawidłowy ciąg JSON na typ danych JSON.
W pliku Bicep użyj funkcji json .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| arg1 | Tak | string | Wartość, która ma być konwertowana na format JSON. Ciąg musi być poprawnie sformatowany ciąg JSON. |
Wartość zwracana
Typ danych JSON z określonego ciągu lub wartość pusta w przypadku określenia wartości null .
Uwagi
Jeśli musisz uwzględnić wartość parametru lub zmienną w obiekcie JSON, użyj funkcji format , aby utworzyć ciąg przekazywany do funkcji.
Możesz również użyć wartości null(), aby uzyskać wartość null.
Przykład
W poniższym przykładzie pokazano, jak używać json funkcji. Zwróć uwagę, że można przekazać null element dla pustego obiektu.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"jsonEmptyObject": {
"type": "string",
"defaultValue": "null"
},
"jsonObject": {
"type": "string",
"defaultValue": "{\"a\": \"b\"}"
},
"jsonString": {
"type": "string",
"defaultValue": "\"test\""
},
"jsonBoolean": {
"type": "string",
"defaultValue": "true"
},
"jsonInt": {
"type": "string",
"defaultValue": "3"
},
"jsonArray": {
"type": "string",
"defaultValue": "[[1,2,3 ]"
},
"concatValue": {
"type": "string",
"defaultValue": "demo value"
}
},
"resources": [
],
"outputs": {
"emptyObjectOutput": {
"type": "bool",
"value": "[empty(json(parameters('jsonEmptyObject')))]"
},
"objectOutput": {
"type": "object",
"value": "[json(parameters('jsonObject'))]"
},
"stringOutput": {
"type": "string",
"value": "[json(parameters('jsonString'))]"
},
"booleanOutput": {
"type": "bool",
"value": "[json(parameters('jsonBoolean'))]"
},
"intOutput": {
"type": "int",
"value": "[json(parameters('jsonInt'))]"
},
"arrayOutput": {
"type": "array",
"value": "[json(parameters('jsonArray'))]"
},
"concatObjectOutput": {
"type": "object",
"value": "[json(concat('{\"a\": \"', parameters('concatValue'), '\"}'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| emptyObjectOutput | Wartość logiczna | Prawda |
| objectOutput | Objekt | {"a": "b"} |
| stringOutput | String | test |
| wartość logicznaOutput | Wartość logiczna | Prawda |
| intOutput | Integer | 3 |
| arrayOutput | Tablica | [ 1, 2, 3 ] |
| concatObjectOutput | Objekt | { "a": "demo value" } |
length
length(arg1)
Zwraca liczbę elementów w tablicy, znaki w ciągu lub właściwości na poziomie głównym w obiekcie.
W Bicep użyj funkcji length .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| arg1 | Tak | tablica, ciąg lub obiekt | Tablica do użycia do pobierania liczby elementów, ciągu do użycia do pobierania liczby znaków lub obiektu do pobrania liczby właściwości na poziomie głównym. |
Wartość zwracana
Int.
Przykład
W poniższym przykładzie pokazano, jak używać z length tablicą i ciągiem:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"arrayToTest": {
"type": "array",
"defaultValue": [
"one",
"two",
"three"
]
},
"stringToTest": {
"type": "string",
"defaultValue": "One Two Three"
},
"objectToTest": {
"type": "object",
"defaultValue": {
"propA": "one",
"propB": "two",
"propC": "three",
"propD": {
"propD-1": "sub",
"propD-2": "sub"
}
}
}
},
"resources": [],
"outputs": {
"arrayLength": {
"type": "int",
"value": "[length(parameters('arrayToTest'))]"
},
"stringLength": {
"type": "int",
"value": "[length(parameters('stringToTest'))]"
},
"objectLength": {
"type": "int",
"value": "[length(parameters('objectToTest'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| arrayLength | Int | 3 |
| stringLength | Int | 13 |
| objectLength | Int | 100 |
null
null()
Zwraca wartość null.
Funkcja null nie jest dostępna w Bicep. Zamiast tego użyj słowa kluczowego null .
Parametry
Funkcja null nie akceptuje żadnych parametrów.
Wartość zwracana
Wartość, która zawsze ma wartość null.
Przykład
W poniższym przykładzie użyto funkcji null.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"emptyOutput": {
"type": "bool",
"value": "[empty(null())]"
}
}
}
Dane wyjściowe z poprzedniego przykładu to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| emptyOutput | Bool | Prawda |
objectKeys
objectKeys(object)
Zwraca klucze z obiektu, w którym obiekt jest kolekcją par klucz-wartość.
W Bicep użyj funkcji objectKeys .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| obiekt | Tak | obiekt | Obiekt, który jest kolekcją par klucz-wartość. |
Wartość zwracana
Tablicy.
Przykład
W poniższym przykładzie pokazano, jak używać z objectKeys obiektem:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"obj": {
"a": 1,
"b": 2
}
},
"resources": [],
"outputs": {
"keyArray": {
"type": "array",
"value": "[objectKeys(variables('obj'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| keyArray | Tablica | [ "a", "b" ] |
W formacie JSON obiekt jest nieurządkowaną kolekcją par klucz/wartość zero lub więcej. Kolejność może być różna w zależności od implementacji. Na przykład funkcja Bicep items() sortuje obiekty w kolejności alfabetycznej. W innych miejscach można zachować oryginalną kolejność. Ze względu na ten niedeterminizm należy unikać wprowadzania wszelkich założeń dotyczących porządkowania kluczy obiektów podczas pisania kodu, który wchodzi w interakcje z parametrami i danymi wyjściowymi wdrożeń.
płytkieMerge
shallowMerge(inputArray)
Łączy tablicę obiektów, w której scalane są tylko obiekty najwyższego poziomu. Oznacza to, że jeśli scalane obiekty zawierają zagnieżdżone obiekty, te zagnieżdżone obiekty nie są głęboko scalane; zamiast tego są one całkowicie zastępowane przez odpowiednią właściwość z scalanego obiektu.
W Bicep użyj płytkiej funkcjiMerge .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| inputArray | Tak | tablica | Tablica obiektów. |
Wartość zwracana
Obiekt .
Przykład
W poniższym przykładzie pokazano, jak używać polecenia shallowMerge:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"firstArray": [
{
"one": "a"
},
{
"two": "b"
},
{
"two": "c"
}
],
"secondArray": [
{
"one": "a",
"nested": {
"a": 1,
"nested": {
"c": 3
}
}
},
{
"two": "b",
"nested": {
"b": 2
}
}
]
},
"resources": [],
"outputs": {
"firstOutput": {
"type": "object",
"value": "[shallowMerge(variables('firstArray'))]"
},
"secondOutput": {
"type": "object",
"value": "[shallowMerge(variables('secondArray'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| firstOutput | obiekt | {"one":"a","two":"c"} |
| secondOutput | obiekt | {"one":"a","nested":{"b":2},"two":"b"} |
firstOutput pokazuje właściwości z scalanych obiektów są łączone w nowy obiekt. Jeśli występują właściwości powodujące konflikt (tj. właściwości o tej samej nazwie), właściwość z ostatniego obiektu, który jest scalany, zwykle ma pierwszeństwo.
secondOutput pokazuje płytkie scalanie nie rekursywnie scala tych zagnieżdżonych obiektów. Zamiast tego cały zagnieżdżony obiekt jest zastępowany przez odpowiednią właściwość z scalanego obiektu.
unia
union(arg1, arg2, arg3, ...)
Zwraca pojedynczą tablicę lub obiekt ze wszystkimi elementami z parametrów. W przypadku tablic są uwzględniane zduplikowane wartości raz. W przypadku obiektów zduplikowane nazwy właściwości są uwzględniane tylko raz.
W Bicep użyj funkcji union .
Parametry
| Parametr | Wymagania | Type | Opis |
|---|---|---|---|
| arg1 | Tak | tablica lub obiekt | Pierwsza wartość, która ma być używana do łączenia elementów. |
| arg2 | Tak | tablica lub obiekt | Druga wartość, która ma być używana do łączenia elementów. |
| więcej argumentów | Nie. | tablica lub obiekt | Więcej wartości do użycia do łączenia elementów. |
Wartość zwracana
Tablica lub obiekt.
Uwagi
Funkcja union używa sekwencji parametrów do określenia kolejności i wartości wyniku.
W przypadku tablic funkcja iteruje każdy element w pierwszym parametrze i dodaje go do wyniku, jeśli nie jest jeszcze obecny. Następnie powtarza proces dla drugiego parametru i wszelkich dodatkowych parametrów. Jeśli wartość jest już obecna, jej wcześniejsze umieszczenie w tablicy jest zachowywane.
W przypadku obiektów nazwy właściwości i wartości z pierwszego parametru są dodawane do wyniku. W przypadku późniejszych parametrów wszystkie nowe nazwy są dodawane do wyniku. Jeśli późniejszy parametr ma właściwość o tej samej nazwie, ta wartość zastępuje istniejącą wartość. Kolejność właściwości nie jest gwarantowana.
Funkcja union scala nie tylko elementy najwyższego poziomu, ale także rekursywnie scala wszystkie zagnieżdżone tablice i obiekty w nich. Zobacz drugi przykład w poniższej sekcji.
Przykład
W poniższym przykładzie pokazano, jak używać z union tablicami i obiektami:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"firstObject": {
"type": "object",
"defaultValue": {
"one": "a",
"two": "b",
"three": "c1"
}
},
"secondObject": {
"type": "object",
"defaultValue": {
"three": "c2",
"four": "d",
"five": "e"
}
},
"firstArray": {
"type": "array",
"defaultValue": [ "one", "two", "three" ]
},
"secondArray": {
"type": "array",
"defaultValue": [ "three", "four" ]
}
},
"resources": [
],
"outputs": {
"objectOutput": {
"type": "object",
"value": "[union(parameters('firstObject'), parameters('secondObject'))]"
},
"arrayOutput": {
"type": "array",
"value": "[union(parameters('firstArray'), parameters('secondArray'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| objectOutput | Objekt | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
| arrayOutput | Tablica | ["one", "two", "three", "four"] |
W poniższym przykładzie przedstawiono możliwość głębokiego scalania:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"firstObject": {
"property": {
"one": "a",
"two": "b",
"three": "c1"
},
"nestedArray": [
1,
2
]
},
"secondObject": {
"property": {
"three": "c2",
"four": "d",
"five": "e"
},
"nestedArray": [
3,
4
]
},
"firstArray": [
[
"one",
"two"
],
[
"three"
]
],
"secondArray": [
[
"three"
],
[
"four",
"two"
]
]
},
"resources": [],
"outputs": {
"objectOutput": {
"type": "Object",
"value": "[union(variables('firstObject'), variables('secondObject'))]"
},
"arrayOutput": {
"type": "Array",
"value": "[union(variables('firstArray'), variables('secondArray'))]"
}
}
}
Dane wyjściowe z poprzedniego przykładu to:
| Nazwisko | Typ | Wartość |
|---|---|---|
| objectOutput | Objekt | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]} |
| arrayOutput | Tablica | [["one","two"],["three"],["four","two"]] |
Jeśli zagnieżdżone tablice zostały scalone, wartość objectOutput.nestedArray będzie wynosić [1, 2, 3, 4], a wartość arrayOutput będzie wynosić [["jeden", "dwa", "trzy"], ["trzy", "cztery", "dwa"]].
Następne kroki
- Aby zapoznać się z opisem sekcji w szablonie usługi ARM, zobacz Omówienie struktury i składni szablonów usługi ARM.