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.

tableau

array(convertToArray)

Convertit la valeur en tableau.

Dans Bicep, utilisez la fonction array.

Paramètres

Valeur retournée

Tableau.

Exemple

L’exemple suivant montre comment utiliser la array fonction avec différents types :

{
  "$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 des valeurs par défaut de l’exemple précédent est la suivante :

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

Cette fonction peut prendre un nombre quelconque d’arguments et accepter soit des chaînes, soit 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 des valeurs par défaut de l’exemple précédent est la suivante :

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 des valeurs par défaut de l’exemple précédent est la suivante :

contient

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

Valeur retournée

Vrai si la fonction trouve l’élément ; sinon, faux.

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 des valeurs par défaut de l’exemple précédent est la suivante :

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

Valeur retournée

Tableau. Quand vous ne fournissez aucun paramètre, il retourne un tableau vide.

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 des valeurs par défaut de l’exemple précédent est la suivante :

distinct

distinct(arrayToModify)

Retourne un nouveau tableau avec toutes les valeurs dupliquées retirées du tableau d’entrée. La fonction conserve l’ordre original de la première occurrence.

Dans Bicep, utilisez la fonction distinct.

Paramètres

Valeur retournée

Un tableau contenant uniquement des éléments uniques du tableau d’entrée. L’ordre des éléments est préservé en fonction de leur première apparition.

Exemple

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

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "numbers": [ 1, 2, 2, 3, 1 ],
    "names": [ "apple", "banana", "apple", "cherry" ],
    "resources": [
      {
        "name": "storage1",
        "type": "Microsoft.Storage/storageAccounts"
      },
      {
        "name": "vm1",
        "type": "Microsoft.Compute/virtualMachines"
      },
      {
        "name": "storage1",
        "type": "Microsoft.Storage/storageAccounts"
      }
    ]
  },
  "outputs": {
    "uniqueNumbers": {
      "type": "array",
      "value": "[distinct(variables('numbers'))]"
    },
    "uniqueNames": {
      "type": "array",
      "value": "[distinct(variables('names'))]"
    },
    "uniqueResources": {
      "type": "array",
      "value": "[distinct(variables('resources'))]"
    }
  }
}

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

vide

empty(itemToTest)

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

Dans Bicep, utilisez la fonction empty.

Paramètres

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 des valeurs par défaut de l’exemple précédent est la suivante :

premier

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

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 first 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 des valeurs par défaut de l’exemple précédent est la suivante :

indexFromEnd

indexFromEnd(sourceArray, reverseIndex)

Retourne un élément du tableau en comptant vers l’arrière à partir de la fin. Cette fonction est utile lorsque vous souhaitez référencer des éléments commençant par la fin d’une liste plutôt que par le début. La tryIndexFromEnd fonction est une version sécurisée de indexFromEnd.

Dans Bicep, utilisez l’opérateur d’accesseur d’index réservé .

Paramètres

Valeur retournée

Élément unique d’un tableau, sélectionné en comptant vers l’arrière à partir de la fin du tableau.

Exemple

L’exemple suivant explique comment utiliser la indexFromEnd fonction :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "items": [
      "apple",
      "banana",
      "orange",
      "grape"
    ]
  },
  "resources": [],
  "outputs": {
    "secondToLast": {
      "type": "string",
      "value": "[indexFromEnd(variables('items'), 2)]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

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

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 n’est pas trouvé, la fonction retourne -1.

Exemples

L’exemple suivant montre comment utiliser les indexOf fonctions 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 :

carrefour

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

Valeur retournée

Tableau ou objet avec les éléments communs.

Exemple

L’exemple suivant montre comment utiliser 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 des valeurs par défaut de l’exemple précédent est la suivante :

dernier

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

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 montre comment utiliser la last 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 des valeurs par défaut de l’exemple précédent est la suivante :

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

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 indexOf fonctions 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 :

longueur

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

Valeur retournée

Un entier.

Exemple

L’exemple suivant montre comment utiliser length 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 des valeurs par défaut de l’exemple précédent est la suivante :

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 suivant, le paramètre siteNames fait référence à un ensemble 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

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 des valeurs par défaut de l’exemple précédent est la suivante :

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

Valeur retournée

Entier représentant la valeur minimale.

Exemple

L’exemple suivant montre comment utiliser 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 des valeurs par défaut de l’exemple précédent est la suivante :

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

Valeur retournée

Tableau d’entiers.

Exemple

L’exemple suivant explique comment utiliser la range fonction :

{
  "$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 des valeurs par défaut de l’exemple précédent est la suivante :

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

Valeur retournée

Tableau ou chaîne.

Exemple

L’exemple suivant saute le nombre spécifié d’éléments dans le tableau ainsi que 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 des valeurs par défaut de l’exemple précédent est la suivante :

prendre

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

Valeur retournée

Tableau ou chaîne.

Exemple

L’exemple suivant prend le nombre spécifié d’éléments d’un tableau et de 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 des valeurs par défaut de l’exemple précédent est la suivante :

tryGet

tryGet(itemToTest, keyOrIndex)

tryGet vous permet d’éviter les échecs de déploiement lors de la tentative d’accès à une propriété ou à un index inexistant dans un objet ou un tableau. Si la clé ou l’index spécifié n’existe pas, tryGet elle retourne null au lieu de lancer une erreur.

Dans Bicep, utilisez l’opérateur safe-dereference .

Paramètres

Valeur retournée

Rend la valeur à la clé ou à l’indice si elle existe. Retour nul si la clé ou l’index est absent ou hors limites.

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#",
  "languageVersion": "2.0",
  "contentVersion": "1.0.0.0",
  "variables": {
    "users": {
      "name": "John Doe",
      "age": 30
    },
    "colors": [
      "red",
      "green"
    ]
  },
  "resources": [],
  "outputs": {
    "region": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'region')]"
    },
    "name": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'name')]"
    },
    "firstColor": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('colors'), 0)]"
    }
  }
}

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

tryIndexFromEnd

tryIndexFromEnd(sourceArray, reverseIndex)

La tryIndexFromEnd fonction est une version sécurisée de indexFromEnd. Il récupère une valeur à partir d’un tableau en comptant vers l’arrière à partir de la fin sans générer d’erreur si l’index est hors limites.

Dans Bicep, utilisez l’opérateur d’accesseur d’index réservé et l’opérateur Dereference Safe .

Paramètres

Valeur retournée

Si l’index est valide (dans les limites du tableau), retourne l’élément de tableau à cet index inverse. Si l’index est hors limites, retourne null au lieu de lever une erreur.

Exemple

L’exemple suivant explique comment utiliser la tryIndexFromEnd fonction :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "items": [
      "apple",
      "banana",
      "orange",
      "grape"
    ]
  },
  "resources": [],
  "outputs": {
    "secondToLast": {
      "type": "string",
      "value": "[tryIndexFromEnd(variables('items'), 2)]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

L’exemple suivant montre un scénario hors limites :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "languageVersion": "2.0",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "items": {
      "type": "array",
      "defaultValue": [
        "apple",
        "banana",
        "orange",
        "grape"
      ]
    }
  },
  "resources": {},
  "outputs": {
    "outOfBound": {
      "type": "string",
      "nullable": true,
      "value": "[tryIndexFromEnd(parameters('items'), 5)]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

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

Valeur retournée

Objet ou tableau.

Remarques

Il union function 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 union fonction fusionne non seulement les éléments de premier niveau, mais fusionne aussi récursivement tous les objets imbriqués en leur sein. Les valeurs de tableaux imbriqués ne sont pas fusionnées. Consultez le deuxième exemple dans la section suivante.

Exemple

L’exemple suivant montre comment utiliser union 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 des valeurs par défaut de l’exemple précédent est la suivante :

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 :

Si des tableaux imbriqués étaient fusionnés, la valeur de objectOutput.nestedArray est [1, 2, 3, 4], et la valeur de ArrayOutput est [["un », « deux », « trois"], ["trois », « quatre », « deux"]].

Étapes suivantes

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