Arrayfunktionen für ARM-Vorlagen

Artikel
02/09/2024

In diesem Artikel werden die Voralgenfunktionen für die Arbeit mit Arrays beschrieben.

Informationen zu einem Array mit Zeichenfolgenwerten, die durch einen Wert getrennt sind, finden Sie unter split.

Tipp

Wir empfehlen Bicep, weil es dieselben Funktionen wie ARM-Vorlagen bietet und die Syntax einfacher zu verwenden ist. Weitere Informationen finden Sie unter array-Funktionen.

array

array(convertToArray)

Konvertiert den Wert in ein Array.

Verwenden Sie in Bicep die array-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
convertToArray	Ja	int, string, array oder object	Der Wert, der in ein Array konvertiert werden soll.

Rückgabewert

Ein -Array.

Beispiel

Im folgenden Beispiel wird die Verwendung der array-Funktion mit unterschiedlichen Typen gezeigt.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "intToConvert": {
      "type": "int",
      "defaultValue": 1
    },
    "stringToConvert": {
      "type": "string",
      "defaultValue": "efgh"
    },
    "objectToConvert": {
      "type": "object",
      "defaultValue": {
        "a": "b",
        "c": "d"
      }
    }
  },
  "resources": [
  ],
  "outputs": {
    "intOutput": {
      "type": "array",
      "value": "[array(parameters('intToConvert'))]"
    },
    "stringOutput": {
      "type": "array",
      "value": "[array(parameters('stringToConvert'))]"
    },
    "objectOutput": {
      "type": "array",
      "value": "[array(parameters('objectToConvert'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
intOutput	Array	[1]
stringOutput	Array	["efgh"]
objectOutput	Array	[{"a": "b", "c": "d"}]

concat

concat(arg1, arg2, arg3, ...)

Kombiniert mehrere Arrays und gibt das verkettete Array zurück oder kombiniert mehrere Zeichenfolgenwerte und gibt die verkettete Zeichenfolge zurück.

Verwenden Sie in Bicep die concat-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array oder Zeichenfolge	Das erste Array bzw. die erste Zeichenfolge für die Verkettung.
mehr Argumente	Nein	Array oder Zeichenfolge	Weitere Arrays oder Strings in sequenzieller Reihenfolge für die Verkettung.

Diese Funktion akzeptiert eine beliebige Anzahl von Argumenten und Zeichenfolgen oder Arrays für die Parameter. Sie können jedoch nicht sowohl Arrays als auch Zeichenfolgen für Parameter angeben. Arrays werden nur mit anderen Arrays verkettet.

Rückgabewert

Eine Zeichenfolge oder ein Array aus verketteten Werten.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie zwei Arrays kombiniert werden.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstArray": {
      "type": "array",
      "defaultValue": [
        "1-1",
        "1-2",
        "1-3"
      ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [
        "2-1",
        "2-2",
        "2-3"
      ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "return": {
      "type": "array",
      "value": "[concat(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
return	Array	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

Das folgende Beispiel zeigt, wie zwei Zeichenfolgenwerte kombiniert werden und eine verkettete Zeichenfolge zurückgeben.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "prefix": {
      "type": "string",
      "defaultValue": "prefix"
    }
  },
  "resources": [],
  "outputs": {
    "concatOutput": {
      "type": "string",
      "value": "[concat(parameters('prefix'), '-', uniqueString(resourceGroup().id))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
concatOutput	String	prefix-5yj4yjf5mbg72

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

createArray

createArray(arg1, arg2, arg3, ...)

Erstellt ein Array auf der Grundlage der Parameter.

Die createArray-Funktion wird in Bicep nicht unterstützt. Informationen zum Erstellen eines Arrays finden Sie unter dem Bicep-Datentyp array.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
args	Nein	Zeichenfolge, ganze Zahl, Array oder Objekt	Die Werte im Array.

Rückgabewert

Ein -Array. Wenn keine Parameter angegeben werden, wird ein leeres Array zurückgegeben.

Beispiel

Das folgende Beispiel zeigt die Verwendung von „createArray“ mit unterschiedlichen Typen:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "stringArray": {
      "type": "array",
      "value": "[createArray('a', 'b', 'c')]"
    },
    "intArray": {
      "type": "array",
      "value": "[createArray(1, 2, 3)]"
    },
    "objectArray": {
      "type": "array",
      "value": "[createArray(parameters('objectToTest'))]"
    },
    "arrayArray": {
      "type": "array",
      "value": "[createArray(parameters('arrayToTest'))]"
    },
    "emptyArray": {
      "type": "array",
      "value": "[createArray()]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
stringArray	Array	["a", "b", "c"]
intArray	Array	[1, 2, 3]
objectArray	Array	[{"one": "a", "two": "b", "three": "c"}]
arrayArray	Array	[["one", "two", "three"]]
emptyArray	Array	[]

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

first

first(arg1)

Gibt das erste Element des Arrays oder das erste Zeichen der Zeichenfolge zurück.

Verwenden Sie in Bicep die first-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array oder Zeichenfolge	Der Wert, dessen erstes Element oder Zeichen abgerufen wird.

Rückgabewert

Der Typ (Zeichenfolge, ganze Zahl, Array oder Objekt) des ersten Elements in einem Array oder das erste Zeichen einer Zeichenfolge.

Beispiel

Im folgenden Beispiel wird die Verwendung der first-Funktion mit einem Array und einer Zeichenfolge gezeigt.

{
  "$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" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayOutput": {
      "type": "string",
      "value": "[first(parameters('arrayToTest'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[first('One Two Three')]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	String	one
stringOutput	String	O

indexOf

indexOf(arrayToSearch, itemToFind)

Gibt eine ganze Zahl für den Index des ersten Vorkommens eines Elements in einem Array zurück. Beim Vergleich von Zeichenfolgen wird die Groß-/Kleinschreibung beachtet.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arrayToSearch	Ja	array	Das Array, das zum Suchen des Indexes des gesuchten Elements verwendet werden soll.
itemToFind	Ja	int, string, array oder object	Das Element, das im Array gesucht werden soll.

Rückgabewert

Eine ganze Zahl, die den ersten Index des Elements in dem Array darstellt. Der Index ist nullbasiert. Wenn das Element nicht gefunden wird, wird -1 zurückgegeben.

Beispiele

Das folgende Beispiel zeigt die Verwendung der Funktionen „indexOf“ und „lastIndexOf“:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "names": [
      "one",
      "two",
      "three"
    ],
    "numbers": [
      4,
      5,
      6
    ],
    "collection": [
      "[variables('names')]",
      "[variables('numbers')]"
    ],
    "duplicates": [
      1,
      2,
      3,
      1
    ]
  },
  "resources": [],
  "outputs": {
    "index1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'two')]"
    },
    "index2": {
      "type": "int",
      "value": "[indexOf(variables('names'), 'one')]"
    },
    "notFoundIndex1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'Three')]"
    },
    "index3": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), 4)]"
    },
    "index4": {
      "type": "int",
      "value": "[indexOf(variables('numbers'), 6)]"
    },
    "notFoundIndex2": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), '5')]"
    },
    "index5": {
      "type": "int",
      "value": "[indexOf(variables('collection'), variables('numbers'))]"
    },
    "index6": {
      "type": "int",
      "value": "[indexOf(variables('duplicates'), 1)]"
    },
    "index7": {
      "type": "int",
      "value": "[lastIndexOf(variables('duplicates'), 1)]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
index1	INT	1
index2	INT	0
index3	INT	0
index4	INT	2
index5	INT	1
index6	INT	0
index7	INT	3
notFoundIndex1	INT	-1
notFoundIndex2	INT	-1

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, wie Sie die Schnittmenge mit Arrays und Objekten verwenden können.

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

last

last(arg1)

Gibt das letzte Element des Arrays bzw. das letzte Zeichen der Zeichenfolge zurück.

Verwenden Sie in Bicep die last-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array oder Zeichenfolge	Der Wert, dessen letztes Element oder Zeichen abgerufen wird.

Rückgabewert

Der Typ (Zeichenfolge, ganze Zahl, Array oder Objekt) des letzten Elements in einem Array oder das letzte Zeichen einer Zeichenfolge.

Beispiel

Im folgenden Beispiel wird die Verwendung der last-Funktion mit einem Array und einer Zeichenfolge gezeigt.

{
  "$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" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayOutput": {
      "type": "string",
      "value": "[last(parameters('arrayToTest'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[last('One Two Three')]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	String	three
stringOutput	String	e

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Gibt eine ganze Zahl für den Index des letzten Vorkommens eines Elements in einem Array zurück. Beim Vergleich von Zeichenfolgen wird die Groß-/Kleinschreibung beachtet.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arrayToSearch	Ja	array	Das Array, das zum Suchen des Indexes des gesuchten Elements verwendet werden soll.
itemToFind	Ja	int, string, array oder object	Das Element, das im Array gesucht werden soll.

Rückgabewert

Eine ganze Zahl, die den letzten Index des Elements in dem Array darstellt. Der Index ist nullbasiert. Wenn das Element nicht gefunden wird, wird -1 zurückgegeben.

Beispiele

Das folgende Beispiel zeigt die Verwendung der Funktionen „indexOf“ und „lastIndexOf“:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "names": [
      "one",
      "two",
      "three"
    ],
    "numbers": [
      4,
      5,
      6
    ],
    "collection": [
      "[variables('names')]",
      "[variables('numbers')]"
    ],
    "duplicates": [
      1,
      2,
      3,
      1
    ]
  },
  "resources": [],
  "outputs": {
    "index1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'two')]"
    },
    "index2": {
      "type": "int",
      "value": "[indexOf(variables('names'), 'one')]"
    },
    "notFoundIndex1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'Three')]"
    },
    "index3": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), 4)]"
    },
    "index4": {
      "type": "int",
      "value": "[indexOf(variables('numbers'), 6)]"
    },
    "notFoundIndex2": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), '5')]"
    },
    "index5": {
      "type": "int",
      "value": "[indexOf(variables('collection'), variables('numbers'))]"
    },
    "index6": {
      "type": "int",
      "value": "[indexOf(variables('duplicates'), 1)]"
    },
    "index7": {
      "type": "int",
      "value": "[lastIndexOf(variables('duplicates'), 1)]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
index1	INT	1
index2	INT	0
index3	INT	0
index4	INT	2
index5	INT	1
index6	INT	0
index7	INT	3
notFoundIndex1	INT	-1
notFoundIndex2	INT	-1

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, wie man length mit einem Array und einer Zeichenkette verwendet.

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

Sie können diese Funktion mit einem Array verwenden, um bei der Erstellung von Ressourcen die Anzahl der Iterationen anzugeben. Im folgenden Beispiel bezieht sich der Parameter siteNames auf ein Array von Namen, die bei der Erstellung der Websites verwendet werden.

"copy": {
  "name": "websitescopy",
  "count": "[length(parameters('siteNames'))]"
}

Weitere Informationen zum Verwenden dieser Funktion mit einem Array finden Sie unter Ressourceniteration in ARM-Vorlagen.

max

max(arg1)

Gibt den größten Wert aus einem Array mit ganzen Zahlen oder einer durch Trennzeichen getrennten Liste mit ganzen Zahlen zurück.

Verwenden Sie in Bicep die max-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array mit ganzen Zahlen oder durch Trennzeichen getrennte Liste mit ganzen Zahlen	Die Auflistung, aus der der größte Wert abgerufen werden soll.

Rückgabewert

Ein Ganzzahlwert, der den größten Wert darstellt.

Beispiel

Das folgende Beispiel zeigt, wie man max mit einem Array und einer Liste von Ganzzahlen verwendet.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ 0, 3, 2, 5, 4 ]
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "int",
      "value": "[max(parameters('arrayToTest'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[max(0,3,2,5,4)]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Int	5
intOutput	Int	5

Min

min(arg1)

Gibt den kleinsten Wert aus einem Array mit ganzen Zahlen oder einer durch Trennzeichen getrennten Liste mit ganzen Zahlen zurück.

Verwenden Sie in Bicep die min-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array mit ganzen Zahlen oder durch Trennzeichen getrennte Liste mit ganzen Zahlen	Die Auflistung, aus der der kleinste Wert abgerufen werden soll.

Rückgabewert

Ein Ganzzahlwert, der den kleinsten Wert darstellt.

Beispiel

Das folgende Beispiel zeigt, wie man min mit einem Array und einer Liste von Ganzzahlen verwendet.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ 0, 3, 2, 5, 4 ]
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "int",
      "value": "[min(parameters('arrayToTest'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[min(0,3,2,5,4)]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Int	0
intOutput	Int	0

range

range(startIndex, count)

Erstellt ein Array mit ganzen Zahlen, das mit einer ganzen Zahl beginnt und eine bestimmte Zahl von Elementen enthält.

Verwenden Sie in Bicep die range-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
startIndex	Ja	INT	Die erste ganze Zahl im Array. Die Summe von „startIndex“ und „count“ darf nicht größer sein als 2147483647.
count	Ja	INT	Die Anzahl von ganzen Zahlen im Array. Muss eine positive ganze Zahl bis 10000 sein.

Rückgabewert

Ein Array mit ganzen Zahlen.

Beispiel

Das folgende Beispiel zeigt, wie Sie die Bereichsfunktion verwenden.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "startingInt": {
      "type": "int",
      "defaultValue": 5
    },
    "numberOfElements": {
      "type": "int",
      "defaultValue": 3
    }
  },
  "resources": [],
  "outputs": {
    "rangeOutput": {
      "type": "array",
      "value": "[range(parameters('startingInt'),parameters('numberOfElements'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
rangeOutput	Array	[5, 6, 7]

skip

skip(originalValue, numberToSkip)

Gibt ein Array mit allen Elementen gemäß der angegebenen Anzahl im Array bzw. eine Zeichenfolge mit allen Zeichen gemäß der angegebenen Anzahl in der Zeichenfolge zurück.

Verwenden Sie in Bicep die skip-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
originalValue	Ja	Array oder Zeichenfolge	Array oder Zeichenfolge, wo Elemente übersprungen werden sollen.
numberToSkip	Ja	INT	Die Anzahl der zu überspringenden Elemente bzw. Zeichen. Wenn dieser Wert 0 (null) oder kleiner ist, werden alle Elemente oder Zeichen in dem Wert zurückgegeben. Ist er größer als die Länge des Arrays bzw. der Zeichenfolge, wird ein leeres Array bzw. eine leere Zeichenfolge zurückgegeben.

Rückgabewert

Ein Array oder eine Zeichenfolge.

Beispiel

Im folgenden Beispiel wird die angegebene Anzahl von Elementen im Array und Zeichen in der Zeichenfolge übersprungen.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "elementsToSkip": {
      "type": "int",
      "defaultValue": 2
    },
    "testString": {
      "type": "string",
      "defaultValue": "one two three"
    },
    "charactersToSkip": {
      "type": "int",
      "defaultValue": 4
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "array",
      "value": "[skip(parameters('testArray'),parameters('elementsToSkip'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[skip(parameters('testString'),parameters('charactersToSkip'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Array	["three"]
stringOutput	String	two three

take

take(originalValue, numberToTake)

Gibt ein Array oder eine Zeichenkette zurück. Ein Array hat die angegebene Anzahl von Elementen ab dem Beginn des Arrays. Eine Zeichenkette hat die angegebene Anzahl von Zeichen vom Anfang der Zeichenkette an.

Verwenden Sie in Bicep die take-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
originalValue	Ja	Array oder Zeichenfolge	Das Array bzw. die Zeichenfolge, wo die Elemente entnommen werden sollen.
numberToTake	Ja	INT	Die Anzahl der zu entnehmenden Elemente bzw. Zeichen. Ist dieser Wert 0 oder kleiner, wird ein leeres Array bzw. eine leere Zeichenfolge zurückgegeben. Ist er größer als die Länge des entsprechenden Arrays bzw. der Zeichenfolge, werden alle Elemente des Arrays bzw. der Zeichenfolge zurückgegeben.

Rückgabewert

Ein Array oder eine Zeichenfolge.

Beispiel

Im folgenden Beispiel wird die angegebene Anzahl von Elementen aus dem Array und Zeichen aus der Zeichenfolge entnommen.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "elementsToTake": {
      "type": "int",
      "defaultValue": 2
    },
    "testString": {
      "type": "string",
      "defaultValue": "one two three"
    },
    "charactersToTake": {
      "type": "int",
      "defaultValue": 2
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "array",
      "value": "[take(parameters('testArray'),parameters('elementsToTake'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[take(parameters('testString'),parameters('charactersToTake'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Array	["one", "two"]
stringOutput	String	on

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 Objekte. Geschachtelte Arraywerte werden nicht zusammengeführt. Sehen Sie sich das zweite Beispiel im folgenden Abschnitt an.

Beispiel

Das folgende Beispiel zeigt, wie Union mit Arrays und Objekten verwendet werden kann.

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

Freigeben über

Arrayfunktionen für ARM-Vorlagen

array

Parameter

Rückgabewert

Beispiel

concat

Parameter

Rückgabewert

Beispiel

contains

Parameter

Rückgabewert

Beispiel

createArray

Parameter

Rückgabewert

Beispiel

empty

Parameter

Rückgabewert

Beispiel

first

Parameter

Rückgabewert

Beispiel

indexOf

Parameter

Rückgabewert

Beispiele

Schnittmenge

Parameter

Rückgabewert

Beispiel

last

Parameter

Rückgabewert

Beispiel

lastIndexOf

Parameter

Rückgabewert

Beispiele

length

Parameter

Rückgabewert

Beispiel

max

Parameter

Rückgabewert

Beispiel

Min

Parameter

Rückgabewert

Beispiel

range

Parameter

Rückgabewert

Beispiel

skip

Parameter

Rückgabewert

Beispiel

take

Parameter

Rückgabewert

Beispiel

union

Parameter

Rückgabewert

Hinweise

Beispiel

Nächste Schritte

Feedback

Zusätzliche Ressourcen