Tömbfüggvények ARM-sablonokhoz
Ez a cikk a tömbök használatát szolgáló sablonfüggvényeket ismerteti.
Az értékekkel tagolt sztringértékek tömbjének lekéréséhez lásd a felosztást.
Tipp.
A Bicep használatát javasoljuk, mert ugyanazokkal a képességekkel rendelkezik, mint az ARM-sablonok, és a szintaxis használata egyszerűbb. További információ: tömbfüggvények .
array
array(convertToArray)
Az értéket tömbté alakítja.
A Bicepben használja a tömbfüggvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| convertToArray | Igen | int, sztring, tömb vagy objektum | A tömbké konvertálandó érték. |
Visszaadott érték
Egy tömb.
Példa
Az alábbi példa bemutatja, hogyan használhatja a tömbfüggvényt különböző típusokkal.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| intOutput | Tömb | [1] |
| stringOutput | Tömb | ["efgh"] |
| objectOutput | Tömb | [{"a": "b", "c": "d"}] |
összefűzés
concat(arg1, arg2, arg3, ...)
Több tömböt egyesít, és visszaadja az összefűzött tömböt, vagy több sztringértéket egyesít, és visszaadja az összefűzött sztringet.
A Bicepben használja az összefűző függvényt .
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb vagy sztring | Az összefűzés első tömbje vagy sztringje. |
| további argumentumok | Nem | tömb vagy sztring | További tömbök vagy sztringek szekvenciális sorrendben az összefűzéshez. |
Ez a függvény tetszőleges számú argumentumot tartalmazhat, és sztringeket vagy tömböket is elfogadhat a paraméterekhez. A paraméterekhez azonban nem adhat meg tömböket és sztringeket. A tömbök csak más tömbökkel vannak összefűzve.
Visszaadott érték
Összefűzött értékek sztringje vagy tömbje.
Példa
Az alábbi példa bemutatja, hogyan kombinálhat két tömböt.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| vissza | Tömb | ["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"] |
Az alábbi példa bemutatja, hogyan kombinálhat két sztringértéket, és hogyan ad vissza egy összefűzött sztringet.
{
"$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))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| concatOutput | Sztring | előtag-5yj4yjf5mbg72 |
contains
contains(container, itemToFind)
Ellenőrzi, hogy egy tömb tartalmaz-e értéket, egy objektum tartalmaz-e kulcsot, vagy egy sztring tartalmaz-e részsztringet. A sztringek összehasonlítása megkülönbözteti a kis- és nagybetűk értékét. Ha azonban egy objektum tartalmaz kulcsot, az összehasonlítás érzéketlen.
A Bicepben használja a contains függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| tároló | Igen | tömb, objektum vagy sztring | A keresendő értéket tartalmazó érték. |
| itemToFind | Igen | sztring vagy int | A keresendő érték. |
Visszaadott érték
Igaz , ha az elem megtalálható; ellenkező esetben Hamis.
Példa
Az alábbi példa bemutatja, hogyan használható különböző típusú:
{
"$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')]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| stringTrue | Bool | Igaz |
| stringFalse | Bool | Hamis |
| objectTrue | Bool | Igaz |
| objectFalse | Bool | Hamis |
| arrayTrue | Bool | Igaz |
| arrayFalse | Bool | Hamis |
createArray
createArray(arg1, arg2, arg3, ...)
Tömböt hoz létre a paraméterekből.
A Bicepben a createArray függvény nem támogatott. Tömb létrehozásához tekintse meg a Bicep-tömb adattípusát.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| args | Nem | Sztring, egész szám, tömb vagy objektum | A tömb értékei. |
Visszaadott érték
Egy tömb. Ha nincsenek megadva paraméterek, az üres tömböt ad vissza.
Példa
Az alábbi példa bemutatja, hogyan használható a createArray különböző típusok esetén:
{
"$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()]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| stringArray | Tömb | ["a", "b", "c"] |
| intArray | Tömb | [1, 2, 3] |
| objectArray | Tömb | [{"one": "a", "two": "b", "three": "c"}] |
| arrayArray | Tömb | [["egy", "kettő", "három"]] |
| emptyArray | Tömb | [] |
üres
empty(itemToTest)
Meghatározza, hogy egy tömb, objektum vagy sztring üres-e.
A Bicepben használja az üres függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| itemToTest | Igen | tömb, objektum vagy sztring | Az az érték, amely ellenőrzi, hogy üres-e. |
Visszaadott érték
Igaz értéket ad vissza, ha az érték üres; ellenkező esetben Hamis.
Példa
Az alábbi példa azt ellenőrzi, hogy egy tömb, objektum és sztring üres-e.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayEmpty | Bool | Igaz |
| objectEmpty | Bool | Igaz |
| stringEmpty | Bool | Igaz |
első
first(arg1)
A tömb első elemét vagy a sztring első karakterét adja vissza.
A Bicepben használja az első függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb vagy sztring | Az első elem vagy karakter beolvasásának értéke. |
Visszaadott érték
A tömb első elemének típusa (sztring, int, tömb vagy objektum) vagy egy sztring első karaktere.
Példa
Az alábbi példa bemutatja, hogyan használható az első függvény tömbökkel és sztringekkel.
{
"$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')]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Sztring | egy |
| stringOutput | Sztring | O |
indexOf
indexOf(arrayToSearch, itemToFind)
Egy elem első előfordulásának indexét adja vissza egy tömbben. Az összehasonlítás a sztringek esetében megkülönbözteti a kis- és nagybetűket.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arrayToSearch | Igen | array | A keresett elem indexének megkereséséhez használandó tömb. |
| itemToFind | Igen | int, sztring, tömb vagy objektum | A tömbben keresendő elem. |
Visszaadott érték
A tömbben lévő elem első indexét jelölő egész szám. Az index nulla alapú. Ha az elem nem található, a rendszer a -1 értéket adja vissza.
Példák
Az alábbi példa az indexOf és a lastIndexOf függvény használatát mutatja be:
{
"$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)]"
}
}
}
Az előző példa kimenete a következő:
| Név | Típus | Érték |
|---|---|---|
| index1 | egész | 0 |
| index2 | egész | 0 |
| index3 | egész | 0 |
| index4 | egész | 2 |
| index5 | egész | 0 |
| index6 | egész | 0 |
| index7 | egész | 3 |
| notFoundIndex1 | egész | 1- |
| notFoundIndex2 | egész | 1- |
Kereszteződés
intersection(arg1, arg2, arg3, ...)
Egyetlen tömböt vagy objektumot ad vissza a paraméterek gyakori elemeivel.
A Bicepben használja a metszetfüggvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb vagy objektum | A gyakori elemek megkereséséhez elsőként használandó érték. |
| arg2 | Igen | tömb vagy objektum | A második érték, amelyet a gyakori elemek kereséséhez használunk. |
| további argumentumok | Nem | tömb vagy objektum | További értékek a gyakori elemek megtalálásához. |
Visszaadott érték
Egy tömb vagy objektum a közös elemekkel.
Példa
Az alábbi példa bemutatja, hogyan használható metszet tömbökkel és objektumokkal.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| objectOutput | Objektum | {"one": "a", "három": "c"} |
| arrayOutput | Tömb | ["two", "three"] |
utolsó
last(arg1)
A tömb utolsó elemét, vagy a sztring utolsó karakterét adja vissza.
A Bicepben használja az utolsó függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb vagy sztring | Az utolsó elem vagy karakter beolvasásának értéke. |
Visszaadott érték
A tömb utolsó elemének típusa (sztring, int, tömb vagy objektum) vagy egy sztring utolsó karaktere.
Példa
Az alábbi példa bemutatja, hogyan használható az utolsó függvény tömbökkel és sztringekkel.
{
"$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')]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Sztring | három |
| stringOutput | Sztring | e |
lastIndexOf
lastIndexOf(arrayToSearch, itemToFind)
Egy tömbben lévő elem utolsó előfordulásának indexét adja vissza egész számként. Az összehasonlítás a sztringek esetében megkülönbözteti a kis- és nagybetűket.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arrayToSearch | Igen | array | A keresett elem indexének megkereséséhez használandó tömb. |
| itemToFind | Igen | int, sztring, tömb vagy objektum | A tömbben keresendő elem. |
Visszaadott érték
A tömbben lévő elem utolsó indexét jelölő egész szám. Az index nulla alapú. Ha az elem nem található, a rendszer a -1 értéket adja vissza.
Példák
Az alábbi példa az indexOf és a lastIndexOf függvény használatát mutatja be:
{
"$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)]"
}
}
}
Az előző példa kimenete a következő:
| Név | Típus | Érték |
|---|---|---|
| index1 | egész | 0 |
| index2 | egész | 0 |
| index3 | egész | 0 |
| index4 | egész | 2 |
| index5 | egész | 0 |
| index6 | egész | 0 |
| index7 | egész | 3 |
| notFoundIndex1 | egész | 1- |
| notFoundIndex2 | egész | 1- |
length (hossz)
length(arg1)
Egy tömb elemeinek számát, egy sztringben szereplő karaktereket vagy egy objektum gyökérszintű tulajdonságait adja vissza.
A Bicepben használja a hosszfüggvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb, sztring vagy objektum | Az elemek számának lekéréséhez használandó tömb, a karakterek számának lekéréséhez használandó sztring vagy a gyökérszintű tulajdonságok számának lekéréséhez használni kívánt objektum. |
Visszaadott érték
Egy int.
Példa
Az alábbi példa bemutatja, hogyan használható a hossz tömbökkel és sztringekkel.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayLength | Int | 3 |
| stringLength | Int | 13 |
| objectLength | Int | 4 |
Ezt a függvényt tömbökkel is használhatja az erőforrások létrehozásakor az iterációk számának megadásához. A következő példában a siteNames paraméter a webhelyek létrehozásakor használandó nevek tömbjére hivatkozik.
"copy": {
"name": "websitescopy",
"count": "[length(parameters('siteNames'))]"
}
A függvény tömbökkel való használatával kapcsolatos további információkért lásd : Erőforrás-iteráció ARM-sablonokban.
max.
max(arg1)
Az egész számok tömbjének vagy az egész számok vesszővel tagolt listájának maximális értékét adja vissza.
A Bicepben használja a maximális függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | egész számok tömbje vagy egész számok vesszővel tagolt listája | A gyűjtemény a maximális érték lekéréséhez. |
Visszaadott érték
A maximális értéket képviselő int.
Példa
Az alábbi példa bemutatja, hogyan használható a max tömb és az egész számok listája.
{
"$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)]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Int | 5 |
| intOutput | Int | 5 |
p
min(arg1)
Az egész számok tömbjének vagy az egész számok vesszővel tagolt listájának minimális értékét adja vissza.
A Bicepben használja a min függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | egész számok tömbje vagy egész számok vesszővel tagolt listája | A gyűjtemény a minimális érték lekéréséhez. |
Visszaadott érték
A minimális értéket képviselő int.
Példa
Az alábbi példa bemutatja, hogyan használható a min tömb és az egész számok listája.
{
"$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)]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Int | 0 |
| intOutput | Int | 0 |
Tartomány
range(startIndex, count)
Egy kezdő egész számból álló egész számtömböt hoz létre, amely számos elemet tartalmaz.
A Bicepben használja a tartományfüggvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| startIndex | Igen | egész | A tömb első egésze. A startIndex és a darabszám összege nem lehet nagyobb, mint 2147483647. |
| darabszám | Igen | egész | A tömb egész számainak száma. Legfeljebb 10000 nem negatív egész szám lehet. |
Visszaadott érték
Egész számok tömbje.
Példa
Az alábbi példa a tartományfüggvény használatát mutatja be.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| rangeOutput | Tömb | [5, 6, 7] |
Kihagyás
skip(originalValue, numberToSkip)
Olyan tömböt ad vissza, amely a tömb megadott száma után az összes elemet tartalmazza, vagy egy karakterláncot ad vissza, amely a megadott szám után az összes karaktert tartalmazza a sztringben.
A Bicepben használja a kihagyó függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| originalValue | Igen | tömb vagy sztring | A kihagyáshoz használandó tömb vagy sztring. |
| numberToSkip | Igen | egész | Az kihagyandó elemek vagy karakterek száma. Ha ez az érték 0 vagy kevesebb, a rendszer az érték összes elemét vagy karakterét visszaadja. Ha nagyobb, mint a tömb vagy a sztring hossza, a függvény üres tömböt vagy sztringet ad vissza. |
Visszaadott érték
Tömb vagy sztring.
Példa
Az alábbi példa kihagyja a tömb megadott számú elemét és a sztringben megadott számú karaktert.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Tömb | ["három"] |
| stringOutput | Sztring | két három |
Elvétel
take(originalValue, numberToTake)
Tömböt vagy sztringet ad vissza. A tömbök a tömb kezdetétől megadott számú elemet tartalmaznak. A sztringek a sztring elejétől megadott számú karaktert tartalmaznak.
A Bicepben használja a take függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| originalValue | Igen | tömb vagy sztring | Az elemeket átvenni kívánt tömb vagy sztring. |
| numberToTake | Igen | egész | A felvenni kívánt elemek vagy karakterek száma. Ha ez az érték 0 vagy kevesebb, a függvény egy üres tömböt vagy sztringet ad vissza. Ha nagyobb, mint az adott tömb vagy sztring hossza, a rendszer visszaadja a tömb vagy sztring összes elemét. |
Visszaadott érték
Tömb vagy sztring.
Példa
Az alábbi példa a tömb megadott számú elemét és egy sztringből származó karaktereket veszi fel.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| arrayOutput | Tömb | ["egy", "kettő"] |
| stringOutput | Sztring | ekkor |
unió
union(arg1, arg2, arg3, ...)
Egyetlen tömböt vagy objektumot ad vissza a paraméterek összes elemével. Tömbök esetén a rendszer egyszer tartalmazza az ismétlődő értékeket. Objektumok esetén a rendszer csak egyszer tartalmazza a duplikált tulajdonságneveket.
A Bicepben használja az egyesítő függvényt.
Paraméterek
| Paraméter | Kötelező | Típus | Leírás |
|---|---|---|---|
| arg1 | Igen | tömb vagy objektum | Az első elemillesztéshez használható érték. |
| arg2 | Igen | tömb vagy objektum | Az elemek összekapcsolásához használt második érték. |
| további argumentumok | Nem | tömb vagy objektum | További értékek az elemek összekapcsolásához. |
Visszaadott érték
Tömb vagy objektum.
Megjegyzések
Az egyesítő függvény a paraméterek sorrendjét használja az eredmény sorrendjének és értékeinek meghatározásához.
Tömbök esetén a függvény végigfut az első paraméter minden elemén, és hozzáadja az eredményhez, ha még nincs jelen. Ezután megismétli a második paraméter és minden további paraméter folyamatát. Ha egy érték már jelen van, a tömb korábbi elhelyezése megmarad.
Objektumok esetén a rendszer hozzáadja az első paraméter tulajdonságneveit és értékeit az eredményhez. A későbbi paraméterek esetében a rendszer minden új nevet hozzáad az eredményhez. Ha egy későbbi paraméter azonos nevű tulajdonsággal rendelkezik, az az érték felülírja a meglévő értéket. A tulajdonságok sorrendje nem garantált.
Az egyesítő függvény nem csak a legfelső szintű elemeket egyesíti, hanem rekurzív módon egyesíti a bennük lévő beágyazott objektumokat is. A beágyazott tömbértékek nincsenek egyesítve. Lásd a második példát a következő szakaszban.
Példa
Az alábbi példa bemutatja, hogyan használható az egyesítő tömbökkel és objektumokkal.
{
"$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'))]"
}
}
}
Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:
| Név | Típus | Érték |
|---|---|---|
| objectOutput | Objektum | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
| arrayOutput | Tömb | ["egy", "kettő", "három", "négy"] |
Az alábbi példa a mélyegyesítési képességet mutatja be:
{
"$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'))]"
}
}
}
Az előző példa kimenete a következő:
| Név | Típus | Érték |
|---|---|---|
| objectOutput | Objektum | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]} |
| arrayOutput | Tömb | [["egy","két"],["három"],["négy","kettő"]] |
Ha a beágyazott tömbök egyesítve lennének, akkor az objectOutput.nestedArray értéke [1, 2, 3, 4], a arrayOutput értéke pedig [["one", "two", "three"], ["three", "four", "two"]].
Következő lépések
- Az ARM-sablonok szakaszainak leírását az ARM-sablonok szerkezetének és szintaxisának ismertetése című témakörben találja.