Objektové funkce pro šablony ARM
Resource Manager poskytuje několik funkcí pro práci s objekty v šabloně Azure Resource Manageru (šablona ARM):
Tip
Doporučujeme Bicep, protože nabízí stejné možnosti jako šablony ARM a syntaxe se snadněji používá. Další informace najdete v tématu Funkce objektů .
obsahuje
contains(container, itemToFind)
Kontroluje, zda pole obsahuje hodnotu, objekt obsahuje klíč nebo řetězec obsahuje podřetězce. Porovnání řetězců se rozlišují malá a velká písmena. Při testování, pokud objekt obsahuje klíč, je však porovnání nerozlišující malá a velká písmena.
V Bicep použijte funkci contains .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| kontejner | Ano | pole, objekt nebo řetězec | Hodnota, která obsahuje hodnotu, kterou chcete najít. |
| itemToFind | Ano | řetězec nebo int | Hodnota, kterou chcete najít. |
Vrácená hodnota
Hodnota True , pokud je položka nalezena; v opačném případě false.
Příklad
Následující příklad ukazuje, jak se používá contains s různými typy:
{
"$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')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| stringTrue | Bool | True |
| stringFalse | Bool | False |
| objectTrue | Bool | True |
| objectFalse | Bool | False |
| arrayTrue | Bool | True |
| arrayFalse | Bool | False |
Createobject
createObject(key1, value1, key2, value2, ...)
Vytvoří objekt z klíčů a hodnot.
Bicep createObject funkci nepodporuje. Vytvoření objektu pomocí {}. Viz objekty.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| key1 | No | string | Název klíče. |
| hodnota1 | No | int, boolean, string, object nebo array | Hodnota klíče. |
| další klíče | No | string | Další názvy klíčů. |
| více hodnot | No | int, boolean, string, object nebo array | Další hodnoty pro klíče. |
Funkce přijímá pouze sudý počet parametrů. Každý klíč musí mít odpovídající hodnotu.
Vrácená hodnota
Objekt s každou dvojicí klíč a hodnota.
Příklad
Následující příklad vytvoří objekt z různých typů hodnot.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je objekt s následující newObject hodnotou:
{
"intProp": 1,
"stringProp": "abc",
"boolProp": true,
"arrayProp": ["a", "b", "c"],
"objectProp": {"key1": "value1"}
}
empty
empty(itemToTest)
Určuje, zda je pole, objekt nebo řetězec prázdné.
V Bicep použijte prázdnou funkci.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| itemToTest | Ano | pole, objekt nebo řetězec | Hodnota, která se má zkontrolovat, jestli je prázdná. |
Vrácená hodnota
Vrátí hodnotu True , pokud je hodnota prázdná. V opačném případě vrátí hodnotu False.
Příklad
Následující příklad zkontroluje, zda pole, objekt a řetězec jsou prázdné.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayEmpty | Bool | True |
| objectEmpty | Bool | True |
| stringEmpty | Bool | True |
Průsečíku
intersection(arg1, arg2, arg3, ...)
Vrátí jedno pole nebo objekt se společnými prvky z parametrů.
V Bicep použijte funkci průniku.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole nebo objekt | První hodnota, která se má použít k vyhledání společných prvků. |
| arg2 | Ano | pole nebo objekt | Druhá hodnota, která se má použít k vyhledání společných prvků. |
| další argumenty | No | pole nebo objekt | Další hodnoty, které se mají použít k vyhledání běžných prvků. |
Vrácená hodnota
Pole nebo objekt se společnými prvky.
Příklad
Následující příklad ukazuje, jak se používají intersection s poli a objekty.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| objectOutput | Object | {"one": "a", "three": "c"} |
| arrayOutput | Pole | ["two", "three"] |
položky
items(object)
Převede objekt slovníku na pole. Viz toObject o převodu pole na objekt.
V Bicep použijte položky.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| objekt | Ano | objekt | Objekt slovníku, který se má převést na pole. |
Vrácená hodnota
Pole objektů pro převedený slovník. Každý objekt v poli má key vlastnost, která obsahuje hodnotu klíče pro slovník. Každý objekt má value také vlastnost, která obsahuje vlastnosti objektu.
Příklad
Následující příklad převede objekt slovníku na pole. Pro každý objekt v poli vytvoří nový objekt s upravenými hodnotami.
{
"$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')]"
}
}
}
Předchozí příklad vrátí:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
Následující příklad ukazuje pole, které je vráceno z funkce 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')]"
}
}
}
Příklad vrátí:
"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
}
}
]
}
Ve formátu JSON je objekt neuspořádanou kolekcí párů klíč/hodnota nula nebo více. Řazení se může lišit v závislosti na implementacích. Například funkce Bicep items() seřadí objekty v abecedním pořadí. Na jiných místech lze původní řazení zachovat. Kvůli tomuto ne determinismu nepoužívejte žádné předpoklady týkající se řazení klíčů objektů při psaní kódu, které interaguje s parametry nasazení a výstupy.
json
json(arg1)
Převede platný řetězec JSON na datový typ JSON.
V Bicep použijte funkci JSON .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | string | Hodnota, která se má převést na JSON. Řetězec musí být správně naformátovaný řetězec JSON. |
Vrácená hodnota
Datový typ JSON ze zadaného řetězce nebo prázdná hodnota, pokud je zadána hodnota null .
Poznámky
Pokud potřebujete do objektu JSON zahrnout hodnotu parametru nebo proměnnou, použijte funkci format k vytvoření řetězce, který funkci předáte.
K získání hodnoty null můžete použít také hodnotu null( ).
Příklad
Následující příklad ukazuje, jak používat json funkci. Všimněte si, že můžete předat null prázdný objekt.
{
"$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'), '\"}'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| emptyObjectOutput | Logická hodnota | True |
| objectOutput | Object | {"a": "b"} |
| stringOutput | String | test |
| booleanOutput | Logická hodnota | True |
| intOutput | Celé číslo | 3 |
| arrayOutput | Pole | [ 1, 2, 3 ] |
| concatObjectOutput | Object | { "a": "demo value" } |
length
length(arg1)
Vrátí počet prvků v poli, znaky v řetězci nebo vlastnosti kořenové úrovně v objektu.
V Bicep použijte funkci délky .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole, řetězec nebo objekt | Pole, které se má použít pro získání počtu prvků, řetězec, který se má použít pro získání počtu znaků, nebo objekt, který se má použít pro získání počtu vlastností kořenové úrovně. |
Vrácená hodnota
Int.
Příklad
Následující příklad ukazuje, jak se používá length s polem a řetězcem:
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayLength | Int | 3 |
| stringLength | Int | 13 |
| objectLength | Int | 4 |
null
null()
Vrátí hodnotu null.
Funkce null není v Bicep dostupná. null Místo toho použijte klíčové slovo.
Parametry
Funkce null nepřijímá žádné parametry.
Vrácená hodnota
Hodnota, která je vždy null.
Příklad
Následující příklad používá funkci 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())]"
}
}
}
Výstup z předchozího příkladu je:
| Name | Typ | Hodnota |
|---|---|---|
| emptyOutput | Bool | True |
objectKeys
objectKeys(object)
Vrátí klíče z objektu, kde je objekt kolekcí párů klíč-hodnota.
V Bicep použijte funkci objectKeys .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| objekt | Ano | objekt | Objekt, což je kolekce párů klíč-hodnota. |
Vrácená hodnota
Pole.
Příklad
Následující příklad ukazuje, jak se používá objectKeys s objektem:
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu je:
| Name | Typ | Hodnota |
|---|---|---|
| keyArray | Pole | [ "a", "b" ] |
Ve formátu JSON je objekt neuspořádanou kolekcí párů klíč/hodnota nula nebo více. Řazení se může lišit v závislosti na implementacích. Například funkce Bicep items() seřadí objekty v abecedním pořadí. Na jiných místech lze původní řazení zachovat. Kvůli tomuto ne determinismu nepoužívejte žádné předpoklady týkající se řazení klíčů objektů při psaní kódu, které interaguje s parametry nasazení a výstupy.
shallowMerge
shallowMerge(inputArray)
Kombinuje pole objektů, kde jsou sloučeny pouze objekty nejvyšší úrovně. To znamená, že pokud sloučené objekty obsahují vnořené objekty, tyto vnořené objekty nejsou hluboce sloučeny; místo toho jsou zcela nahrazeny odpovídající vlastností z slučujícího objektu.
V Bicep použijte funkci shallowMerge .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| inputArray | Ano | pole | Pole objektů. |
Vrácená hodnota
Objekt.
Příklad
Následující příklad ukazuje, jak používat 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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| firstOutput | objekt | {"one":"a","two":"c"} |
| secondOutput | objekt | {"one":"a","vnořený":{"b":2},"two":"b"} |
FirstOutput ukazuje vlastnosti z slučujících objektů jsou sloučeny do nového objektu. Pokud existují konfliktní vlastnosti (tj. vlastnosti se stejným názvem), vlastnost z posledního sloučeného objektu má obvykle přednost.
secondOutput ukazuje, že slučování mělkých objektů rekurzivně nesloučí tyto vnořené objekty. Místo toho se celý vnořený objekt nahradí odpovídající vlastností z objektu sloučení.
sjednocení
union(arg1, arg2, arg3, ...)
Vrátí jednu matici nebo objekt se všemi prvky z parametrů. U polí se duplicitní hodnoty zahrnou jednou. U objektů jsou duplicitní názvy vlastností zahrnuty pouze jednou.
V Bicep použijte sjednocovacího funkce.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole nebo objekt | První hodnota, která se má použít pro spojování prvků. |
| arg2 | Ano | pole nebo objekt | Druhá hodnota, která se má použít pro spojování prvků. |
| další argumenty | No | pole nebo objekt | Další hodnoty, které se mají použít pro spojování prvků. |
Vrácená hodnota
Pole nebo objekt.
Poznámky
Funkce sjednocení používá posloupnost parametrů k určení pořadí a hodnot výsledku.
U polí funkce iteruje každý prvek v prvním parametru a přidá ji do výsledku, pokud ještě není k dispozici. Potom tento proces zopakuje pro druhý parametr a všechny další parametry. Pokud již existuje hodnota, zachová se její dřívější umístění v poli.
Pro objekty se do výsledku přidají názvy vlastností a hodnoty z prvního parametru. Pro pozdější parametry se do výsledku přidají všechny nové názvy. Pokud má pozdější parametr vlastnost se stejným názvem, tato hodnota přepíše existující hodnotu. Pořadí vlastností není zaručeno.
Sjednocovací funkce slučuje nejen prvky nejvyšší úrovně, ale také rekurzivně slučuje všechny vnořené pole a objekty v nich. Podívejte se na druhý příklad v následující části.
Příklad
Následující příklad ukazuje použití union s poli a objekty:
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| objectOutput | Object | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
| arrayOutput | Pole | ["one", "two", "three", "four"] |
Následující příklad ukazuje možnosti hloubkového sloučení:
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu je:
| Name | Typ | Hodnota |
|---|---|---|
| objectOutput | Object | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3;4]} |
| arrayOutput | Pole | [["one";"two"],["three"],["four";"two"]] |
Pokud byly vnořené matice sloučeny, hodnota objectOutput.nestedArray by byla [1, 2, 3, 4] a hodnota arrayOutput by byla [["jedna", "two", "three"], ["three", "four", "two"]].
Další kroky
- Popis oddílů v šabloně ARM najdete v tématu Vysvětlení struktury a syntaxe šablon ARM.