Maticové funkce pro šablony ARM
Tento článek popisuje funkce šablon pro práci s poli.
Pokud chcete získat pole řetězcových hodnot oddělených hodnotou, podívejte se na rozdělení.
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 maticových funkcích.
pole
array(convertToArray)
Převede hodnotu na pole.
V Bicep použijte maticové funkce.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| convertToArray | Ano | int, string, array nebo object | Hodnota, která se má převést na pole. |
Vrácená hodnota
Pole.
Příklad
Následující příklad ukazuje, jak používat maticovou funkci s různými typy.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| intOutput | Pole | [1] |
| stringOutput | Pole | ["eryth"] |
| objectOutput | Pole | [{"a": "b", "c": "d"}] |
concat
concat(arg1, arg2, arg3, ...)
Kombinuje více polí a vrací zřetězenou matici nebo kombinuje více řetězcových hodnot a vrací zřetězený řetězec.
V Bicep použijte funkci concat .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole nebo řetězec | První pole nebo řetězec pro zřetězení. |
| další argumenty | No | pole nebo řetězec | Více polí nebo řetězců v sekvenčním pořadí pro zřetězení |
Tato funkce může přijmout libovolný počet argumentů a pro parametry může přijímat řetězce nebo pole. Pro parametry ale nemůžete zadat pole i řetězce. Pole jsou zřetězena pouze s jinými poli.
Vrácená hodnota
Řetězec nebo pole zřetězených hodnot.
Příklad
Následující příklad ukazuje, jak zkombinovat dvě pole.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| return | Pole | ["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"] |
Následující příklad ukazuje, jak zkombinovat dvě řetězcové hodnoty a vrátit zřetězený řetězec.
{
"$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))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| concatOutput | String | prefix-5yj4yjf5mbg72 |
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 používat obsahuje různé 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 |
createArray
createArray(arg1, arg2, arg3, ...)
Vytvoří z parametrů pole.
V Bicep createArray není funkce podporovaná. Pokud chcete vytvořit pole, podívejte se na datový typ pole Bicep.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| args | No | String, Integer, Array nebo Object | Hodnoty v poli. |
Vrácená hodnota
Pole. Pokud nejsou zadané žádné parametry, vrátí prázdné pole.
Příklad
Následující příklad ukazuje, jak použít createArray s různými typy:
{
"$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()]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| stringArray | Pole | ["a", "b", "c"] |
| intArray | Pole | [1, 2, 3] |
| objectArray | Pole | [{"one": "a", "two": "b", "three": "c"}] |
| arrayArray | Pole | [["one", "two", "three"]] |
| emptyArray | Pole | [] |
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 |
1\.
first(arg1)
Vrátí první prvek pole nebo první znak řetězce.
V Bicep použijte první funkci.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole nebo řetězec | Hodnota pro načtení prvního prvku nebo znaku. |
Vrácená hodnota
Typ (řetězec, int, matice nebo objekt) prvního prvku v matici nebo prvního znaku řetězce.
Příklad
Následující příklad ukazuje, jak použít první funkci 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" ]
}
},
"resources": [
],
"outputs": {
"arrayOutput": {
"type": "string",
"value": "[first(parameters('arrayToTest'))]"
},
"stringOutput": {
"type": "string",
"value": "[first('One Two Three')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | String | jeden |
| stringOutput | String | O |
Indexof
indexOf(arrayToSearch, itemToFind)
Vrátí celé číslo pro index prvního výskytu položky v poli. V porovnání se u řetězců rozlišují malá a velká písmena .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arrayToSearch | Ano | pole | Pole, které se má použít k vyhledání indexu hledané položky. |
| itemToFind | Ano | int, string, array nebo object | Položka, kterou chcete najít v poli. |
Vrácená hodnota
Celé číslo představující první index položky v poli. Index je založený na nule. Pokud se položka nenajde, vrátí se hodnota -1.
Příklady
Následující příklad ukazuje, jak používat funkce indexOf a 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)]"
}
}
}
Výstup z předchozího příkladu je:
| Name | Typ | Hodnota |
|---|---|---|
| index1 | int | 0 |
| index2 | int | 0 |
| index3 | int | 0 |
| index4 | int | 2 |
| index5 | int | 0 |
| index6 | int | 0 |
| index7 | int | 3 |
| notFoundIndex1 | int | -1 |
| notFoundIndex2 | int | -1 |
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 použít průnik 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"] |
Poslední
last(arg1)
Vrátí poslední prvek pole nebo poslední znak řetězce.
V Bicep použijte poslední funkci.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole nebo řetězec | Hodnota pro načtení posledního prvku nebo znaku. |
Vrácená hodnota
Typ (řetězec, int, matice nebo objekt) posledního prvku v poli nebo poslední znak řetězce.
Příklad
Následující příklad ukazuje, jak použít poslední funkci 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" ]
}
},
"resources": [
],
"outputs": {
"arrayOutput": {
"type": "string",
"value": "[last(parameters('arrayToTest'))]"
},
"stringOutput": {
"type": "string",
"value": "[last('One Two Three')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | String | tři |
| stringOutput | String | e |
Lastindexof
lastIndexOf(arrayToSearch, itemToFind)
Vrátí celé číslo pro index posledního výskytu položky v poli. V porovnání se u řetězců rozlišují malá a velká písmena .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arrayToSearch | Ano | pole | Pole, které se má použít k vyhledání indexu hledané položky. |
| itemToFind | Ano | int, string, array nebo object | Položka, kterou chcete najít v poli. |
Vrácená hodnota
Celé číslo představující poslední index položky v poli. Index je založený na nule. Pokud se položka nenajde, vrátí se hodnota -1.
Příklady
Následující příklad ukazuje, jak používat funkce indexOf a 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)]"
}
}
}
Výstup z předchozího příkladu je:
| Name | Typ | Hodnota |
|---|---|---|
| index1 | int | 0 |
| index2 | int | 0 |
| index3 | int | 0 |
| index4 | int | 2 |
| index5 | int | 0 |
| index6 | int | 0 |
| index7 | int | 3 |
| notFoundIndex1 | int | -1 |
| notFoundIndex2 | int | -1 |
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 použít délku 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 |
Tuto funkci s polem můžete použít k určení počtu iterací při vytváření prostředků. V následujícím příkladu by parametr siteNames odkazoval na pole názvů, které se mají použít při vytváření webů.
"copy": {
"name": "websitescopy",
"count": "[length(parameters('siteNames'))]"
}
Další informace o použití této funkce s polem najdete v tématu Iterace prostředků v šablonách ARM.
max
max(arg1)
Vrátí maximální hodnotu z pole celých čísel nebo seznamu celých čísel oddělených čárkami.
V Bicep použijte maximální funkci.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole celých čísel nebo seznam celých čísel oddělených čárkami | Kolekce pro získání maximální hodnoty. |
Vrácená hodnota
Hodnota int představující maximální hodnotu.
Příklad
Následující příklad ukazuje, jak použít maximum s polem a seznamem celých čísel.
{
"$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)]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | Int | 5 |
| intOutput | Int | 5 |
min
min(arg1)
Vrátí minimální hodnotu z pole celých čísel nebo seznamu celých čísel oddělených čárkami.
V Bicep použijte minimální funkci.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| arg1 | Ano | pole celých čísel nebo seznam celých čísel oddělených čárkami | Kolekce pro získání minimální hodnoty. |
Vrácená hodnota
Hodnota int představující minimální hodnotu.
Příklad
Následující příklad ukazuje použití min s polem a seznamem celých čísel.
{
"$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)]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | Int | 0 |
| intOutput | Int | 0 |
range
range(startIndex, count)
Vytvoří pole celých čísel z počátečního celého čísla a obsahující počet položek.
V Bicep použijte funkci rozsahu.
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| Startindex | Ano | int | První celé číslo v poli. Součet startIndex a count nesmí být větší než 2147483647. |
| count | Ano | int | Počet celých čísel v matici Musí být nezáporné celé číslo až 1 0000. |
Vrácená hodnota
Pole celých čísel.
Příklad
Následující příklad ukazuje, jak používat funkci rozsahu.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| rangeOutput | Pole | [5, 6, 7] |
skip
skip(originalValue, numberToSkip)
Vrátí matici se všemi prvky za zadaným číslem v matici nebo vrátí řetězec se všemi znaky za zadaným číslem v řetězci.
V Bicep použijte funkci skip .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| originalValue | Ano | pole nebo řetězec | Pole nebo řetězec, které se mají použít pro přeskočení. |
| numberToSkip | Ano | int | Počet prvků nebo znaků, které chcete přeskočit. Pokud je tato hodnota 0 nebo menší, vrátí se všechny prvky nebo znaky v hodnotě. Pokud je větší než délka pole nebo řetězce, vrátí se prázdné pole nebo řetězec. |
Vrácená hodnota
Pole nebo řetězec.
Příklad
Následující příklad přeskočí zadaný počet prvků v poli a zadaný počet znaků v řetězci.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | Pole | ["tři"] |
| stringOutput | String | dva tři |
take
take(originalValue, numberToTake)
Vrátí matici nebo řetězec. Matice má zadaný počet prvků od začátku pole. Řetězec má zadaný počet znaků od začátku řetězce.
V Bicep použijte funkci take .
Parametry
| Parametr | Požaduje se | Type | Popis |
|---|---|---|---|
| originalValue | Ano | pole nebo řetězec | Pole nebo řetězec, ze které mají být prvky odebrány. |
| numberToTake | Ano | int | Počet prvků nebo znaků, které se mají vzít. Pokud je tato hodnota 0 nebo menší, vrátí se prázdné pole nebo řetězec. Pokud je větší než délka daného pole nebo řetězce, vrátí se všechny prvky v poli nebo řetězci. |
Vrácená hodnota
Pole nebo řetězec.
Příklad
Následující příklad přebírá zadaný počet prvků z pole a znaky z řetězce.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
| Name | Typ | Hodnota |
|---|---|---|
| arrayOutput | Pole | ["one", "two"] |
| stringOutput | String | on |
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 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é objekty v nich. Vnořené hodnoty pole nejsou sloučeny. Podívejte se na druhý příklad v následující části.
Příklad
Následující příklad ukazuje použití sjednocení 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.