Fonctions de tableau pour les modèles ARM

Article
01/11/2024

Cet article décrit les fonctions de modèle pour l’utilisation de tableaux.

Pour obtenir un tableau de valeurs de chaîne délimitée par une valeur, consultez split.

Conseil

Nous recommandons Bicep parce qu’il offre les mêmes fonctionnalités que les modèles ARM et que la syntaxe est plus facile d’utilisation. Pour en savoir plus, consultez les fonctions du tableau.

tableau

array(convertToArray)

Convertit la valeur en tableau.

Dans Bicep, utilisez la fonction array.

Paramètres

Paramètre	Obligatoire	Type	Description
convertToArray	Oui	int, string, array ou object	Valeur à convertir en tableau.

Valeur retournée

Tableau.

Exemple

L’exemple suivant montre comment utiliser la fonction de tableau avec des types différents.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
intOutput	Array	[1]
stringOutput	Array	["efgh"]
objectOutput	Array	[{"a": "b", "c": "d"}]

concat

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

Combine plusieurs tableaux et retourne le tableau concaténé, ou combine plusieurs valeurs de chaîne et renvoie la chaîne concaténée.

Dans Bicep, utilisez la fonction concat.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau ou chaîne	Le premier tableau ou la première chaîne à concaténer.
arguments supplémentaires	Non	tableau ou chaîne	Tableaux ou chaînes supplémentaires en ordre séquentiel pour la concaténation.

Cette fonction peut prendre n’importe quel nombre d’arguments et accepter à la fois des chaînes ou des tableaux pour les paramètres. Toutefois, vous ne pouvez pas fournir à la fois des tableaux et des chaînes pour les paramètres. Les tableaux sont concaténés uniquement avec d’autres tableaux.

Valeur retournée

Chaîne ou tableau de valeurs concaténées.

Exemple

L’exemple suivant montre comment combiner deux tableaux.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
return	Array	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

L’exemple suivant montre comment combiner deux valeurs de chaîne et retourner une chaîne concaténée.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
concatOutput	String	prefix-5yj4yjf5mbg72

contains

contains(container, itemToFind)

Vérifie si un tableau contient une valeur, un objet contient une clé ou une chaîne contient une sous-chaîne. La comparaison de chaînes est sensible à la casse. Cependant, quand vous testez si un objet contient une clé, la comparaison n’est pas sensible à la casse.

Dans Bicep, utilisez la fonction contains.

Paramètres

Paramètre	Obligatoire	Type	Description
conteneur	Oui	tableau, objet ou chaîne	La valeur qui contient la valeur à rechercher.
itemToFind	Oui	chaîne ou entier	La valeur à trouver.

Valeur retournée

True si l’élément est trouvé ; sinon, False.

Exemple

L’exemple suivant montre comment utiliser contains avec différents types :

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
stringTrue	Bool	True
stringFalse	Bool	False
objectTrue	Bool	True
objectFalse	Bool	False
arrayTrue	Bool	True
arrayFalse	Bool	False

createArray

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

Crée un tableau à partir des paramètres.

La fonction createArray n’est pas prise en charge dans Bicep. Pour construire un tableau, consultez le type de données du tableau array de Bicep.

Paramètres

Paramètre	Obligatoire	Type	Description
args	Non	Chaîne, entier, tableau ou objet	Valeurs dans le tableau.

Valeur de retour

Tableau. Quand aucun paramètre n’est fourni, un tableau vide est retourné.

Exemple

L’exemple suivant montre comment utiliser createArray avec différents types :

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
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)

Détermine si un tableau, un objet ou une chaîne est vide.

Dans Bicep, utilisez la fonction empty.

Paramètres

Paramètre	Obligatoire	Type	Description
itemToTest	Oui	tableau, objet ou chaîne	Valeur à vérifier pour voir si elle est vide.

Valeur retournée

Retourne True si la valeur est vide ; sinon, False.

Exemple

L’exemple suivant vérifie si un tableau, un objet et une chaîne sont vides.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayEmpty	Bool	True
objectEmpty	Bool	True
stringEmpty	Bool	True

first

first(arg1)

Retourne le premier élément du tableau ou le premier caractère de la chaîne.

Dans Bicep, utilisez la fonction first.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau ou chaîne	La valeur permettant de récupérer le premier élément ou caractère.

Valeur retournée

Type (chaîne, entier, tableau ou objet) du premier élément d’un tableau ou premier caractère d’une chaîne.

Exemple

L’exemple suivant montre comment utiliser la première fonction avec un tableau et une chaîne.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	String	one
stringOutput	String	O

indexOf

indexOf(arrayToSearch, itemToFind)

Retourne un entier pour l’index de la première occurrence d’un élément dans un tableau. La comparaison respecte la casse pour les chaînes.

Paramètres

Paramètre	Obligatoire	Type	Description
arrayToSearch	Oui	tableau	Tableau à utiliser pour rechercher l’index de l’élément recherché.
itemToFind	Oui	int, string, array ou object	Élément à rechercher dans le tableau.

Valeur retournée

Entier représentant le premier index de l’élément dans le tableau. L’index est basé sur zéro. Si l’élément est introuvable, la valeur -1 est retournée.

Exemples

L'exemple suivant montre comment utiliser les fonctions indexOf et 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)]"
    }
  }
}

La sortie de l’exemple précédent est :

Nom	Type	Valeur
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

intersection

intersection(arg1, arg2, arg3, ...)

Retourne un tableau ou un objet unique avec les éléments communs à partir des paramètres.

Dans Bicep, utilisez la fonction intersection.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	objet ou tableau	La première valeur à utiliser pour rechercher des éléments communs.
arg2	Oui	objet ou tableau	La seconde valeur à utiliser pour rechercher des éléments communs.
arguments supplémentaires	Non	objet ou tableau	Valeurs supplémentaires à utiliser pour rechercher des éléments communs.

Valeur de retour

Tableau ou objet avec les éléments communs.

Exemple

L’exemple suivant indique comment utiliser l’intersection avec les tableaux et les objets.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
objectOutput	Object	{"one": "a", "three": "c"}
arrayOutput	Array	["two", "three"]

last

last(arg1)

Retourne le dernier élément du tableau ou le dernier caractère de la chaîne.

Dans Bicep, utilisez la fonction last.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau ou chaîne	La valeur permettant de récupérer le dernier élément ou caractère.

Valeur retournée

Type (chaîne, entier, tableau ou objet) du dernier élément d’un tableau ou dernier caractère d’une chaîne.

Exemple

L’exemple suivant indique comment utiliser la dernière fonction avec un tableau et une chaîne.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	String	three
stringOutput	String	e

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Retourne un entier pour l’index de la dernière occurrence d’un élément dans un tableau. La comparaison respecte la casse pour les chaînes.

Paramètres

Paramètre	Obligatoire	Type	Description
arrayToSearch	Oui	tableau	Tableau à utiliser pour rechercher l’index de l’élément recherché.
itemToFind	Oui	int, string, array ou object	Élément à rechercher dans le tableau.

Valeur retournée

Entier représentant le dernier index de l’élément dans le tableau. L’index est basé sur zéro. Si l’élément est introuvable, la valeur -1 est retournée.

Exemples

L'exemple suivant montre comment utiliser les fonctions indexOf et 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)]"
    }
  }
}

La sortie de l’exemple précédent est :

Nom	Type	Valeur
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)

Retourne le nombre d’éléments d’un tableau, les caractères d’une chaîne ou les propriétés au niveau de la racine d’un objet.

Dans Bicep, utilisez la fonction length.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau, chaîne ou objet	Tableau à utiliser pour l’obtention du nombre d’éléments, ou chaîne à utiliser pour l’obtention du nombre de caractères, ou l’objet à utiliser pour l’obtention du nombre de propriétés au niveau de la racine.

Valeur retournée

Un entier.

Exemple

L’exemple suivant montre comment utiliser la longueur avec un tableau et une chaîne.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayLength	Int	3
stringLength	Int	13
objectLength	Int	4

Vous pouvez utiliser cette fonction avec un tableau pour spécifier le nombre d’itérations lors de la création de ressources. Dans l’exemple ci-après, le paramètre siteNames fait référence à un tableau de noms à utiliser lors de la création de sites web.

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

Pour plus d’informations sur l’utilisation de cette fonction avec un tableau, consultez Itération sur des ressources dans les modèles ARM.

max

max(arg1)

Retourne la valeur minimale à partir d’un tableau d’entiers ou une liste séparée par des virgules d’entiers.

Dans Bicep, utilisez la fonction max.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau d’entiers ou liste séparée par des virgules d’entiers	Collection permettant d’obtenir la valeur maximale.

Valeur retournée

Entier représentant la valeur maximale.

Exemple

L’exemple suivant montre comment utiliser max avec un tableau et une liste d’entiers.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	Int	5
intOutput	Int	5

min

min(arg1)

Retourne la valeur minimale à partir d’un tableau d’entiers ou une liste séparée par des virgules d’entiers.

Dans Bicep, utilisez la fonction min.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau d’entiers ou liste séparée par des virgules d’entiers	Collection permettant d’obtenir la valeur minimale.

Valeur retournée

Entier représentant la valeur minimale.

Exemple

L’exemple suivant indique comment utiliser la fonction min avec un tableau et une liste d’entiers.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	Int	0
intOutput	Int	0

range

range(startIndex, count)

Crée un tableau d’entiers à partir d’un entier de départ et contenant un nombre d’éléments.

Dans Bicep, utilisez la fonction range.

Paramètres

Paramètre	Obligatoire	Type	Description
startIndex	Oui	int	Premier entier du tableau. La somme de startIndex et count ne doit pas être supérieure à 2147483647.
count	Oui	int	Nombre d’entiers dans le tableau. Il doit s'agir d'un entier non négatif jusqu'à 10000.

Valeur retournée

Tableau d’entiers.

Exemple

L’exemple suivant montre comment utiliser la fonction range.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
rangeOutput	Array	[5, 6, 7]

skip

skip(originalValue, numberToSkip)

Retourne un tableau avec tous les éléments après le nombre spécifié dans le tableau, ou retourne une chaîne avec tous les caractères après le nombre spécifié dans la chaîne.

Dans Bicep, utilisez la fonction skip.

Paramètres

Paramètre	Obligatoire	Type	Description
originalValue	Oui	tableau ou chaîne	Tableau ou chaîne à utiliser pour ignorer les caractères.
numberToSkip	Oui	int	Nombre d’éléments ou de caractères à ignorer. Si cette valeur est inférieure ou égale à 0, tous les éléments ou caractères de la valeur sont renvoyés. Si elle est supérieure à la longueur du tableau ou de la chaîne, un tableau ou une chaîne vide est retourné.

Valeur retournée

Tableau ou chaîne.

Exemple

L’exemple suivant ignore le nombre spécifié d’éléments dans le tableau et le nombre spécifié de caractères dans une chaîne.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	Array	["three"]
stringOutput	String	two three

take

take(originalValue, numberToTake)

Retourne un tableau ou une chaîne. Un tableau possède le nombre spécifié d’éléments depuis le début du tableau. Une chaîne possède le nombre de caractères spécifié à partir du début de la chaîne.

Dans Bicep, utilisez la fonction take.

Paramètres

Paramètre	Obligatoire	Type	Description
originalValue	Oui	tableau ou chaîne	Tableau ou chaîne à partir duquel les éléments sont tirés.
numberToTake	Oui	int	Nombre d’éléments ou de caractères à prendre. Si cette valeur est inférieure ou égale à 0, une chaîne ou un tableau vide est renvoyé. Si elle est supérieure à la longueur du tableau ou de la chaîne, tous les éléments du tableau ou de la chaîne sont retournés.

Valeur retournée

Tableau ou chaîne.

Exemple

L’exemple suivant prend le nombre spécifié d’éléments du tableau, et les caractères d’une chaîne.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	Array	["one", "two"]
stringOutput	String	sur

union

union(arg1, arg2, arg3, ...)

Retourne un tableau ou un objet unique avec tous les éléments communs à partir des paramètres. Pour les tableaux, les valeurs en doublon ne sont incluses qu’une seule fois. Pour les objets, les noms de propriété en double ne sont inclus qu’une seule fois.

Dans Bicep, utilisez la fonction union.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	objet ou tableau	La première valeur à utiliser pour joindre des éléments.
arg2	Oui	objet ou tableau	La seconde valeur à utiliser pour joindre des éléments.
arguments supplémentaires	Non	objet ou tableau	Valeurs supplémentaires à utiliser pour joindre des éléments.

Valeur de retour

Objet ou tableau.

Remarques

La fonction union utilise la séquence des paramètres pour déterminer l’ordre et les valeurs du résultat.

Pour les tableaux, la fonction itère dans chaque élément du premier paramètre et l’ajouter au résultat s’il n’est pas déjà présent. Ensuite, il répète le processus pour le deuxième paramètre et pour les autres paramètres. Si une valeur est déjà présente, sa position antérieure dans le tableau est conservée.

Pour les objets, les noms et les valeurs des propriétés du premier paramètre sont ajoutés au résultat. Pour les paramètres suivants, tous les nouveaux noms sont ajoutés au résultat. Si un paramètre suivant a une propriété du même nom, cette valeur remplace la valeur existante. L’ordre des propriétés n’est pas garanti.

La fonction union fusionne non seulement les éléments de niveau supérieur, mais aussi tous les objets imbriqués dans ceux-ci de manière récursive. Les valeurs de tableaux imbriqués ne sont pas fusionnées. Consultez le deuxième exemple dans la section suivante.

Exemple

L’exemple suivant indique comment utiliser l’intersection avec les tableaux et les objets.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
objectOutput	Object	{"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput	Array	["one", "two", "three", "four"]

L’exemple suivant montre la fonctionnalité de fusion approfondie :

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

La sortie de l’exemple précédent est :

Nom	Type	Valeur
objectOutput	Object	{"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput	Tableau	[["one","two"],["three"],["four","two"]]

Si les tableaux imbriqués étaient fusionnés, alors la valeur objectOutput.nestedArray serait [1, 2, 3, 4] et la valeur arrayOutput serait [["one", "two", "three"], ["three", "four", "two"]].

Étapes suivantes

Pour obtenir une description des sections d’un modèle ARM, consultez Comprendre la structure et la syntaxe des modèles ARM.

Fonctions de tableau pour les modèles ARM

tableau

Paramètres

Valeur retournée

Exemple

concat

Paramètres

Valeur retournée

Exemple

contains

Paramètres

Valeur retournée

Exemple

createArray

Paramètres

Valeur de retour

Exemple

empty

Paramètres

Valeur retournée

Exemple

first

Paramètres

Valeur retournée

Exemple

indexOf

Paramètres

Valeur retournée

Exemples

intersection

Paramètres

Valeur de retour

Exemple

last

Paramètres

Valeur retournée

Exemple

lastIndexOf

Paramètres

Valeur retournée

Exemples

length

Paramètres

Valeur retournée

Exemple

max

Paramètres

Valeur retournée

Exemple

min

Paramètres

Valeur retournée

Exemple

range

Paramètres

Valeur retournée

Exemple

skip

Paramètres

Valeur retournée

Exemple

take

Paramètres

Valeur retournée

Exemple

union

Paramètres

Valeur de retour

Remarques

Exemple

Étapes suivantes

Ressources supplémentaires