Sdílet prostřednictvím

Objektové funkce pro šablony ARM

Resource Manager poskytuje několik funkcí pro práci s objekty v šabloně Azure Resource Manageru (šablona ARM):

Návod

Bicep se doporučuje, 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)

Zkontroluje, jestli 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 contains funkci.

Parametry

Parametr Povinné Typ 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.

Návratová 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 výchozích hodnot z předchozího příkladu je:

Název Typ Hodnota
stringTrue Booleovská hodnota Pravdivé
stringFalse Booleovská hodnota Nepravda
objectTrue Booleovská hodnota Pravdivé
objectFalse Booleovská hodnota Nepravda
arrayTrue Booleovská hodnota Pravdivé
arrayFalse Booleovská hodnota Nepravda

createObject

createObject(key1, value1, key2, value2, ...)

Vytvoří objekt z klíčů a hodnot.

Bicep createObject funkci nepodporuje. Vytvoření objektu pomocí {}. Viz objekty.

Parametry

Parametr Povinné Typ Popis
Klíč1 Ne řetězec Název klíče.
hodnota1 Ne int, boolean, string, object nebo array Hodnota klíče.
další klíče Ne řetězec Další názvy klíčů.
více hodnot Ne 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.

Návratová 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"}
}

prázdný

empty(itemToTest)

Určuje, zda je pole, objekt nebo řetězec prázdné.

V Bicep použijte empty funkci.

Parametry

Parametr Povinné Typ Popis
itemToTest Ano pole, objekt nebo řetězec Hodnota, která se má zkontrolovat, jestli je prázdná.

Návratová 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, jestli 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 výchozích hodnot z předchozího příkladu je:

Název Typ Hodnota
arrayEmpty Booleovská hodnota Pravdivé
objectEmpty Booleovská hodnota Pravdivé
stringEmpty Booleovská hodnota Pravdivé

křižovatka

intersection(arg1, arg2, arg3, ...)

Vrátí jedno pole nebo objekt se společnými prvky z parametrů.

V Bicep použijte intersection funkci.

Parametry

Parametr Povinné Typ Popis
arg1 řekl: 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 Ne pole nebo objekt Další hodnoty, které se mají použít k vyhledání běžných prvků.

Návratová hodnota

Pole nebo objekt se společnými prvky.

Příklad

Následující příklad ukazuje použití 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 výchozích hodnot z předchozího příkladu je:

Název Typ Hodnota
objectOutput Objekt {"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 items funkci.

Parametry

Parametr Povinné Typ Popis
objekt Ano objekt Objekt slovníku, který se má převést na pole.

Návratová 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 a vytvoří nový objekt s upravenými hodnotami pro každý objekt v poli:

{
  "$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é items funkce vrátí:

{
  "$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 json funkci.

Parametry

Parametr Povinné Typ Popis
arg1 řekl: Ano řetězec Hodnota, která se má převést na JSON. Řetězec musí být správně naformátovaný řetězec JSON.

Návratová 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 format funkci k vytvoření řetězce, který funkci předáte.

Můžete také použít null() k získání hodnoty 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 výchozích hodnot z předchozího příkladu je:

Název Typ Hodnota
emptyObjectOutput logický Pravdivé
objectOutput Objekt {"a": "b"}
stringOutput Řetězec test
booleanOutput logický Pravdivé
intOutput Celé číslo 3
arrayOutput Pole [ 1, 2, 3 ]
concatObjectOutput Objekt { "a": "demo value" }

délka

length(arg1)

Vrátí počet prvků v poli, znaky v řetězci nebo vlastnosti kořenové úrovně v objektu.

V Bicep použijte length funkci.

Parametry

Parametr Povinné Typ Popis
arg1 řekl: 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ě.

Návratová 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 výchozích hodnot z předchozího příkladu je:

Název 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.

Návratová hodnota

Hodnota, která je vždy null.

Příklad

Následující příklad používá null funkci:

{
  "$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:

Název Typ Hodnota
emptyOutput Booleovská hodnota Pravdivé

objectKeys

objectKeys(object)

Vrátí klíče z objektu, kde je objekt kolekcí párů klíč-hodnota.

V Bicep použijte objectKeys funkci.

Parametry

Parametr Povinné Typ Popis
objekt Ano objekt Objekt, což je kolekce párů klíč-hodnota.

Návratová 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:

Název 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ů, ve kterých 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 shallowMerge funkci.

Parametry

Parametr Povinné Typ Popis
inputArray Ano pole Pole objektů.

Návratová 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 výchozích hodnot z předchozího příkladu je:

Název 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í.

tryGet

tryGet(itemToTest, keyOrIndex)

tryGet pomáhá vyhnout se selháním nasazení při pokusu o přístup k neexistující vlastnosti nebo indexu v objektu nebo poli. Pokud zadaný klíč nebo index neexistuje, vrátí hodnotu null místo tryGet vyvolání chyby.

V bicep použijte operátor safe-dereference .

Parametry

Parametr Povinné Typ Popis
itemToTest Ano array, object Objekt nebo pole, na které se chcete podívat.
keyOrIndex Ano řetězec, int Klíč nebo index, který se má načíst z pole nebo objektu. Název vlastnosti pro objekty nebo index pro pole.

Návratová hodnota

Vrátí hodnotu v klíči nebo indexu, pokud existuje. Vrátí hodnotu null, pokud klíč nebo index chybí nebo je mimo hranice.

Příklad

Následující příklad zkontroluje, jestli pole, objekt a řetězec jsou prázdné:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "languageVersion": "2.0",
  "contentVersion": "1.0.0.0",
  "variables": {
    "users": {
      "name": "John Doe",
      "age": 30
    },
    "colors": [
      "red",
      "green"
    ]
  },
  "resources": [],
  "outputs": {
    "region": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'region')]"
    },
    "name": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'name')]"
    },
    "firstColor": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('colors'), 0)]"
    }
  }
}

Výstup z předchozího příkladu je:

Název Typ Hodnota
oblast Řetězec (Prázdný)
název Řetězec Jan Novák
firstColor Řetězec Červený

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 union funkci.

Parametry

Parametr Povinné Typ Popis
arg1 řekl: 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 Ne pole nebo objekt Další hodnoty, které se mají použít pro spojování prvků.

Návratová hodnota

Pole nebo objekt.

Poznámky

Funkce union 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 ostatní 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.

Funkce union nejen slučuje 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 výchozích hodnot z předchozího příkladu je:

Název Typ Hodnota
objectOutput Objekt {"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:

Název Typ Hodnota
objectOutput Objekt {"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.

  • Last updated on