Partager via


Fonctions de tableau pour les modèles ARM

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