Objektfunktionen für ARM-Vorlagen
Resource Manager stellt mehrere Funktionen für das Arbeiten mit Objekten in Ihrer Azure Resource Manager-Vorlage (ARM-Vorlage) bereit:
Tipp
Wir empfehlen Bicep, weil es dieselben Funktionen wie ARM-Vorlagen bietet und die Syntax einfacher zu verwenden ist. Weitere Informationen finden Sie unter Objektfunktionen.
contains
contains(container, itemToFind)
Überprüft, ob ein Array einen Wert enthält, ein Objekt einen Schlüssel enthält oder eine Zeichenfolge eine Teilzeichenfolge enthält. Die Groß-/Kleinschreibung wird beim Zeichenfolgenvergleich beachtet. Wenn Sie jedoch testen, ob ein Objekt einen Schlüssel enthält, wird die Groß-/Kleinschreibung beim Vergleich nicht beachtet.
Verwenden Sie in Bicep die contains-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
Container | Ja | Array, Objekt oder Zeichenfolge | Der Wert, der den zu suchenden Wert enthält. |
itemToFind | Ja | Zeichenfolge oder ganze Zahl | Der zu suchende Wert. |
Rückgabewert
True, wenn das Element gefunden wurde; andernfalls False.
Beispiel
Das folgende Beispiel zeigt die Verwendung von contains
mit unterschiedlichen Typen:
{
"$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')]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
stringTrue | Bool | True |
stringFalse | Bool | False |
objectTrue | Bool | True |
objectFalse | Bool | False |
arrayTrue | Bool | True |
arrayFalse | Bool | False |
createObject
createObject(key1, value1, key2, value2, ...)
Erstellt ein Objekt aus den Schlüsseln und Werten.
Die createObject
-Funktion wird von Bicep nicht unterstützt. Erstellen Sie ein-Objekt, indem Sie {}
verwenden. Weitere Informationen finden Sie unter Objekte.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
key1 | Nein | Zeichenfolge | Der Name des Schlüssels. |
value1 | Nein | int, boolean, string, object oder array | Der Wert für den Schlüssel. |
Mehr Schlüssel | Nein | Zeichenfolge | Mehr Namen der Schlüssel. |
Mehr Werte | Nein | int, boolean, string, object oder array | Mehr Werte für die Schlüssel. |
Die Funktion akzeptiert nur eine gerade Anzahl von Parametern. Jeder Schlüssel muss über einen entsprechenden Wert verfügen.
Rückgabewert
Ein Objekt mit jedem Schlüssel-Wert-Paar.
Beispiel
Im folgenden Beispiel wird ein Objekt aus verschiedenen Werttypen erstellt.
{
"$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'))]"
}
}
}
Die Ausgabe des vorherigen Beispiels mit den Standardwerten ist ein Objekt namens newObject
mit folgendem Wert:
{
"intProp": 1,
"stringProp": "abc",
"boolProp": true,
"arrayProp": ["a", "b", "c"],
"objectProp": {"key1": "value1"}
}
empty
empty(itemToTest)
Bestimmt, ob ein Array, Objekt oder eine Zeichenfolge leer ist.
Verwenden Sie in Bicep die empty-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
itemToTest | Ja | Array, Objekt oder Zeichenfolge | Der Wert, für den überprüft werden soll, ob er leer ist. |
Rückgabewert
Gibt True zurück, wenn der Werte leer ist. Andernfalls wird False zurückgegeben.
Beispiel
Im folgenden Beispiel wird überprüft, ob ein Array, Objekt und eine Zeichenfolge leer sind.
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
arrayEmpty | Bool | True |
objectEmpty | Bool | True |
stringEmpty | Bool | True |
Schnittmenge
intersection(arg1, arg2, arg3, ...)
Gibt ein einzelnes Array oder ein Objekt mit den gemeinsamen Elementen aus den Parametern zurück.
Verwenden Sie in Bicep die intersection-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
arg1 | Ja | Array oder Objekt | Der erste Wert für die Suche nach gemeinsamen Elementen. |
arg2 | Ja | Array oder Objekt | Der zweite Wert für die Suche nach gemeinsamen Elementen. |
mehr Argumente | Nein | Array oder Objekt | Mehr Werte für die Suche nach gemeinsamen Elementen. |
Rückgabewert
Ein Array oder Objekt mit den gemeinsamen Elementen.
Beispiel
Das folgende Beispiel zeigt die Verwendung von intersection
mit Arrays und Objekten:
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
objectOutput | Object | {"one": "a", "three": "c"} |
arrayOutput | Array | ["two", "three"] |
items
items(object)
Konvertiert ein Wörterbuchobjekt in ein Array. Informationen zum Konvertieren eines Arrays in ein Objekt finden Sie unter toObject.
Verwenden Sie in Bicep die Elemente.
Parameter
Parameter | Erforderlich | Type | Beschreibung |
---|---|---|---|
Objekt (object) | Ja | Objekt (object) | Das Wörterbuchobjekt, das in ein Array konvertiert werden soll. |
Rückgabewert
Ein Array von Objekten für das konvertierte Wörterbuch. Jedes Objekt in dem Array verfügt über eine key
-Eigenschaft, die den Schlüsselwert für das Wörterbuch enthält. Jedes Objekt verfügt außerdem über eine value
-Eigenschaft, die die Eigenschaften für das Objekt enthält.
Beispiel
Im folgenden Beispiel wird ein Wörterbuchobjekt in ein Array konvertiert. Für jedes Objekt im Array wird ein neues Objekt mit geänderten Werten erstellt.
{
"$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')]"
}
}
}
Im vorherigen Beispiel wird Folgendes zurückgegeben:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
Im folgenden Beispiel wird das Array angezeigt, das von der items-Funktion zurückgegeben wird.
{
"$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')]"
}
}
}
Die Rückgabe des Beispiels lautet wie folgt:
"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
}
}
]
}
In JSON ist ein Objekt eine nicht geordnete Auflistung von null oder mehr Schlüssel-Wert-Paaren. Die Reihenfolge kann je nach Implementierung unterschiedlich sein. Die Items()-Funktion von Bicep sortiert die Objekte beispielsweise in alphabetischer Reihenfolge. An anderen Stellen kann die ursprüngliche Reihenfolge beibehalten werden. Aufgrund dieses Nicht-Determinismus sollten Sie beim Schreiben von Code, der mit den Parametern und Ausgaben der Bereitstellung interagiert, keine Annahmen über die Reihenfolge der Objektschlüssel anstellen.
json
json(arg1)
Konvertiert eine gültige JSON-Zeichenfolge in einen JSON-Datentyp.
Verwenden Sie in Bicep die json-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
arg1 | Ja | Zeichenfolge | Der in JSON zu konvertierende Wert. Die Zeichenfolge muss eine ordnungsgemäß formatierte JSON-Zeichenfolge sein. |
Rückgabewert
Der JSON-Datentyp aus der angegebenen Zeichenfolge oder ein leerer Wert, wenn null angegeben ist.
Hinweise
Wenn Sie einen Parameterwert oder eine Variable in das JSON-Objekt einschließen möchten, verwenden Sie die Funktion Format, um die Zeichenfolge zu erstellen, die Sie an die Funktion übergeben.
Sie können auch null() verwenden, um einen NULL-Wert zu erhalten.
Beispiel
Das folgende Beispiel zeigt die Verwendung der Funktion json
. Beachten Sie, dass Sie null
für ein leeres Objekt übergeben können.
{
"$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'), '\"}'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
emptyObjectOutput | Boolesch | True |
objectOutput | Object | {"a": "b"} |
stringOutput | String | test |
booleanOutput | Boolesch | True |
intOutput | Integer | 3 |
arrayOutput | Array | [ 1, 2, 3 ] |
concatObjectOutput | Object | { "a": "demo value" } |
length
length(arg1)
Gibt die Anzahl von Elementen in einem Array, Zeichen in einer Zeichenfolge oder Eigenschaften auf Stammebene in einem Objekt zurück.
Verwenden Sie in Bicep die length-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
arg1 | Ja | Array, Zeichenfolge oder Objekt | Das Array, von dem die Anzahl der Elemente ermittelt werden soll, die Zeichenfolge, von der die Anzahl der Zeichen ermittelt werden soll, oder das Objekt, von dem die Anzahl der Eigenschaften auf Stammebene ermittelt werden soll. |
Rückgabewert
Eine ganze Zahl.
Beispiel
Das folgende Beispiel zeigt die Verwendung von length
mit einem Array und einer Zeichenfolge:
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
arraylength | Int | 3 |
stringLength | Int | 13 |
objectLength | Int | 4 |
NULL
null()
Gibt NULL zurück.
Die Funktion null
ist in Bicep nicht verfügbar. Verwenden Sie stattdessen das Schlüsselwort null
.
Parameter
Die Funktion „null“ akzeptiert keine Parameter.
Rückgabewert
Ein Wert, der immer „NULL“ lautet.
Beispiel
Das folgende Beispiel verwendet die „null“-Funktion.
{
"$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())]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:
Name | type | Wert |
---|---|---|
emptyOutput | Bool | True |
objectKeys
objectKeys(object)
Gibt die Schlüssel aus einem Objekt zurück, das eine Auflistung von Schlüssel-Wert-Paaren ist.
Verwenden Sie in Bicep die objectKeys-Funktion.
Parameter
Parameter | Erforderlich | Type | Beschreibung |
---|---|---|---|
Objekt (object) | Ja | Objekt | Das Objekt, das eine Auflistung von Schlüssel-Wert-Paaren ist. |
Rückgabewert
Ein -Array.
Beispiel
Das folgende Beispiel zeigt die Verwendung von objectKeys
mit einem Objekt:
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:
Name | type | Wert |
---|---|---|
keyArray | Array | [ "a", "b" ] |
In JSON ist ein Objekt eine nicht geordnete Auflistung von null oder mehr Schlüssel-Wert-Paaren. Die Reihenfolge kann je nach Implementierung unterschiedlich sein. Die Items()-Funktion von Bicep sortiert die Objekte beispielsweise in alphabetischer Reihenfolge. An anderen Stellen kann die ursprüngliche Reihenfolge beibehalten werden. Aufgrund dieses Nicht-Determinismus sollten Sie beim Schreiben von Code, der mit den Parametern und Ausgaben der Bereitstellung interagiert, keine Annahmen über die Reihenfolge der Objektschlüssel anstellen.
shallowMerge
shallowMerge(inputArray)
Kombiniert ein Array von Objekten, wobei nur die Objekte der obersten Ebene zusammengeführt werden. Wenn die zusammengeführten Objekte geschachtelte Objekte enthalten, werden diese verschachtelten Objekte nicht weiter zusammengeführt. Stattdessen werden sie vollständig durch die entsprechende Eigenschaft aus dem zusammenzuführenden Objekt ersetzt.
Verwenden Sie in Bicep die shallowMerge-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
inputArray | Ja | array | Ein Array von -Objekten. |
Rückgabewert
Ein Objekt.
Beispiel
Das folgende Beispiel zeigt die Verwendung von 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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
firstOutput | Objekt | {"one":"a","two":"c"} |
secondOutput | Objekt | {"one":"a","nested":{"b":2},"two":"b"} |
firstOutput zeigt die Eigenschaften der zusammenzuführenden Objekte in einem neuen Objekt an. Wenn Eigenschaften Konflikte verursachen (d. h. Eigenschaften mit identischen Namen), hat die Eigenschaft aus dem letzten zusammengeführten Objekt in der Regel Vorrang.
secondOutput zeigt, dass die flache Zusammenführung diese geschachtelten Objekte nicht rekursiv zusammenführt. Stattdessen wird das gesamte geschachtelte Objekt durch die entsprechende Eigenschaft aus dem zusammenzuführenden Objekt ersetzt.
union
union(arg1, arg2, arg3, ...)
Gibt ein einzelnes Array oder Objekt mit allen Elementen aus den Parametern zurück. Bei Arrays werden doppelte Werte einmal einbezogen. Bei Objekten werden doppelte Eigenschaftsnamen nur einmal einbezogen.
Verwenden Sie in Bicep die union-Funktion.
Parameter
Parameter | Erforderlich | Type | BESCHREIBUNG |
---|---|---|---|
arg1 | Ja | Array oder Objekt | Der erste zum Verknüpfen von Elementen zu verwendende Wert. |
arg2 | Ja | Array oder Objekt | Der zweite zum Verknüpfen von Elementen zu verwendende Wert. |
mehr Argumente | Nein | Array oder Objekt | Mehr zum Verknüpfen von Elementen zu verwendende Werte. |
Rückgabewert
Ein Array oder Objekt.
Hinweise
Die Union-Funktion bestimmt anhand der Abfolge der Parameter die Reihenfolge und die Werte des Ergebnisses.
Bei Arrays durchläuft die Funktion jedes Element im ersten Parameter und fügt es dem Ergebnis hinzu, falls nicht bereits vorhanden. Dann wird der Vorgang für den zweiten und alle weiteren Parameter wiederholt. Wenn ein Wert bereits vorhanden ist, wird seine frühere Platzierung im Array beibehalten.
Für Objekte werden Eigenschaftennamen und Werte aus dem ersten Parameter zum Ergebnis hinzugefügt. Bei späteren Parametern werden dem Ergebnis alle neuen Namen hinzugefügt. Wenn ein späterer Parameter über eine Eigenschaft mit demselben Namen verfügt, überschreibt dieser Wert den vorhandenen Wert. Die Reihenfolge der Eigenschaften ist nicht garantiert.
Die Union-Funktion führt nicht nur die Elemente der obersten Ebene zusammen, sondern auch rekursiv alle darin enthaltenen geschachtelten Arrays und Objekte. Sehen Sie sich das zweite Beispiel im folgenden Abschnitt an.
Beispiel
Das folgende Beispiel zeigt die Verwendung von union
mit Arrays und Objekten:
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:
Name | type | Wert |
---|---|---|
objectOutput | Object | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
arrayOutput | Array | ["one", "two", "three", "four"] |
Das folgende Beispiel zeigt die Funktion „Deep Merge“:
{
"$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'))]"
}
}
}
Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:
Name | type | Wert |
---|---|---|
objectOutput | Object | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]} |
arrayOutput | Array | [["one","two"],["three"],["four","two"]] |
Wenn geschachtelte Arrays zusammengeführt wurden, lautet der Wert von objectOutput.nestedArray „[1, 2, 3, 4]“, und der Wert von arrayOutput wäre „[["one", "two", "three"], ["three", "four", "two"]]“.
Nächste Schritte
- Eine Beschreibung der Abschnitte in einer ARM-Vorlage finden Sie unter Grundlegendes zur Struktur und Syntax von ARM-Vorlagen.