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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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	1
index2	egész	0
index3	egész	0
index4	egész	2
index5	egész	1
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	Szükséges	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	Szükséges	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	Szükséges	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	1
index2	egész	0
index3	egész	0
index4	egész	2
index5	egész	1
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	Szükséges	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	Szükséges	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

min.

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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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	Szükséges	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.