Partager via


Fonctions d’objet pour les modèles ARM

Resource Manager fournit plusieurs fonctions pour vous permettre d’utiliser des objets dans votre modèle Azure Resource Manager (ARM) :

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 plus d’informations, consultez les fonctions d’objet.

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

createObject

createObject(key1, value1, key2, value2, ...)

Crée un objet à partir des clés et des valeurs.

La fonction createObject n’est pas prise en charge par Bicep. Créez un objet en utilisant {}. Consultez Objets.

Paramètres

Paramètre Obligatoire Type Description
key1 Non string Nom de la clé.
valeur1 Non int, boolean, string, object ou array Valeur pour la clé.
clés supplémentaires Non string Noms supplémentaires des clés.
valeurs supplémentaires Non int, boolean, string, object ou array Valeurs supplémentaires pour les clés.

La fonction attend uniquement un nombre pair de paramètres. Chaque clé doit avoir une valeur correspondante.

Valeur de retour

Objet avec chaque paire de clé et valeur.

Exemple

L’exemple suivant crée un objet à partir de différents types de valeurs.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
  ],
  "outputs": {
    "newObject": {
      "type": "object",
      "value": "[createObject('intProp', 1, 'stringProp', 'abc', 'boolProp', true(), 'arrayProp', createArray('a', 'b', 'c'), 'objectProp', createObject('key1', 'value1'))]"
    }
  }
}

La sortie de l’exemple précédent avec les valeurs par défaut est un objet nommé newObject avec la valeur suivante :

{
  "intProp": 1,
  "stringProp": "abc",
  "boolProp": true,
  "arrayProp": ["a", "b", "c"],
  "objectProp": {"key1": "value1"}
}

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

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 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 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"]

items

items(object)

Convertit un objet dictionnaire en un tableau. Consultez toObject sur la conversion d’un tableau en objet.

Dans Bicep, utilisez les éléments.

Paramètres

Paramètre Obligatoire Type Description
object Oui object Objet dictionnaire à convertir en tableau.

Valeur retournée

Tableau d’objets pour le dictionnaire converti. Chaque objet du tableau a une propriété key qui contient la valeur de clé du dictionnaire. Chaque objet possède également une propriété value qui contient les propriétés de l’objet.

Exemple

L’exemple suivant convertit un objet dictionnaire en tableau. Pour chaque objet du tableau, il crée un objet avec les valeurs modifiées.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "copy": [
      {
        "name": "modifiedListOfEntities",
        "count": "[length(items(variables('entities')))]",
        "input": {
          "key": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].key]",
          "fullName": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.displayName]",
          "itemEnabled": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.enabled]"
        }
      }
    ],
    "entities": {
      "item002": {
        "enabled": false,
        "displayName": "Example item 2",
        "number": 200
      },
      "item001": {
        "enabled": true,
        "displayName": "Example item 1",
        "number": 300
      }
    }
  },
  "resources": [],
  "outputs": {
    "modifiedResult": {
      "type": "array",
      "value": "[variables('modifiedListOfEntities')]"
    }
  }
}

L’exemple précédent renvoie :

"modifiedResult": {
  "type": "Array",
  "value": [
    {
      "fullName": "Example item 1",
      "itemEnabled": true,
      "key": "item001"
    },
    {
      "fullName": "Example item 2",
      "itemEnabled": false,
      "key": "item002"
    }
  ]
}

L’exemple suivant montre le tableau renvoyé par la fonction items.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "entities": {
      "item002": {
        "enabled": false,
        "displayName": "Example item 2",
        "number": 200
      },
      "item001": {
        "enabled": true,
        "displayName": "Example item 1",
        "number": 300
      }
    },
    "entitiesArray": "[items(variables('entities'))]"
  },
  "resources": [],
  "outputs": {
    "itemsResult": {
      "type": "array",
      "value": "[variables('entitiesArray')]"
    }
  }
}

L’exemple renvoie :

"itemsResult": {
  "type": "Array",
  "value": [
    {
      "key": "item001",
      "value": {
        "displayName": "Example item 1",
        "enabled": true,
        "number": 300
      }
    },
    {
      "key": "item002",
      "value": {
        "displayName": "Example item 2",
        "enabled": false,
        "number": 200
      }
    }
  ]
}

Dans JSON, un objet est une collection non ordonnée de zéro ou plus paires clé/valeur. L’ordre peut être différent selon les implémentations. Par exemple, la fonction Bicep items() trie les objets par ordre alphabétique. Dans d’autres endroits, l’ordre d’origine peut être conservé. En raison de ce non-déterminisme, évitez de faire des hypothèses sur l’ordre des clés des objets lors de l’écriture du code, ce qui interagit avec les paramètres et les sorties des déploiements.

json

json(arg1)

Convertit une chaîne JSON valide en un type de données JSON.

Dans Bicep, utilisez la fonction json.

Paramètres

Paramètre Obligatoire Type Description
arg1 Oui string Valeur à convertir en JSON. La chaîne doit être une chaîne JSON correctement mise en forme.

Valeur de retour

Le type de données JSON de la chaîne spécifiée ou une valeur vide lorsque null est spécifié.

Notes

Si vous devez inclure une valeur de paramètre ou une variable dans l'objet JSON, utilisez la fonction format pour créer la chaîne que vous transmettez à la fonction.

Vous pouvez également utiliser null() pour obtenir une valeur null.

Exemple

L’exemple suivant explique comment utiliser la fonction json. Notez que vous pouvez transmettre null pour un objet vide.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "jsonEmptyObject": {
      "type": "string",
      "defaultValue": "null"
    },
    "jsonObject": {
      "type": "string",
      "defaultValue": "{\"a\": \"b\"}"
    },
    "jsonString": {
      "type": "string",
      "defaultValue": "\"test\""
    },
    "jsonBoolean": {
      "type": "string",
      "defaultValue": "true"
    },
    "jsonInt": {
      "type": "string",
      "defaultValue": "3"
    },
    "jsonArray": {
      "type": "string",
      "defaultValue": "[[1,2,3 ]"
    },
    "concatValue": {
      "type": "string",
      "defaultValue": "demo value"
    }
  },
  "resources": [
  ],
  "outputs": {
    "emptyObjectOutput": {
      "type": "bool",
      "value": "[empty(json(parameters('jsonEmptyObject')))]"
    },
    "objectOutput": {
      "type": "object",
      "value": "[json(parameters('jsonObject'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[json(parameters('jsonString'))]"
    },
    "booleanOutput": {
      "type": "bool",
      "value": "[json(parameters('jsonBoolean'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[json(parameters('jsonInt'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[json(parameters('jsonArray'))]"
    },
    "concatObjectOutput": {
      "type": "object",
      "value": "[json(concat('{\"a\": \"', parameters('concatValue'), '\"}'))]"
    }
  }
}

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

Nom Type Valeur
emptyObjectOutput Boolean True
objectOutput Object {"a": "b"}
stringOutput String test
booleanOutput Boolean True
intOutput Integer 3
arrayOutput Array [ 1, 2, 3 ]
concatObjectOutput Object {"a": "valeur de démonstration"}

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 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 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

null

null()

Retourne la valeur NULL.

La fonction null n’est pas disponible dans Bicep. Utilisez plutôt le mot clé null.

Paramètres

La fonction null n’accepte aucun paramètre.

Valeur de retour

Valeur qui correspond toujours à null.

Exemple

L’exemple suivant utilise la fonction null.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "emptyOutput": {
      "type": "bool",
      "value": "[empty(null())]"
    }
  }
}

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

Nom Type Valeur
emptyOutput Bool True

objectKeys

objectKeys(object)

Retourne les clés d’un objet, où un objet est une collection de paires clé-valeur.

Dans Bicep, utilisez la fonction objectKeys.

Paramètres

Paramètre Obligatoire Type Description
object Oui object L’objet, qui est une collection de paires clé-valeur.

Valeur retournée

Tableau.

Exemple

L’exemple suivant montre comment utiliser objectKeys avec un objet :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "obj": {
      "a": 1,
      "b": 2
    }
  },
  "resources": [],
  "outputs": {
    "keyArray": {
      "type": "array",
      "value": "[objectKeys(variables('obj'))]"
    }
  }
}

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

Nom Type Value
keyArray Tableau [ "a", "b" ]

Dans JSON, un objet est une collection non ordonnée de zéro ou plus paires clé/valeur. L’ordre peut être différent selon les implémentations. Par exemple, la fonction Bicep items() trie les objets par ordre alphabétique. Dans d’autres endroits, l’ordre d’origine peut être conservé. En raison de ce non-déterminisme, évitez de faire des hypothèses sur l’ordre des clés des objets lors de l’écriture du code, ce qui interagit avec les paramètres et les sorties des déploiements.

shallowMerge

shallowMerge(inputArray)

Combine un tableau d’objets, où seuls les objets de niveau supérieur sont fusionnés. Cela signifie que si les objets fusionnés contiennent des objets imbriqués, ces objets imbriqués ne sont pas fusionnés en profondeur. Au lieu de cela, ils sont entièrement remplacés par la propriété correspondante de l’objet de fusion.

Dans Bicep, utilisez la fonction shallowMerge.

Paramètres

Paramètre Obligatoire Type Description
inputArray Oui tableau Tableau d'objets .

Valeur retournée

Objet.

Exemple

L'exemple suivant montre comment utiliser shallowMerge :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "firstArray": [
      {
        "one": "a"
      },
      {
        "two": "b"
      },
      {
        "two": "c"
      }
    ],
    "secondArray": [
      {
        "one": "a",
        "nested": {
          "a": 1,
          "nested": {
            "c": 3
          }
        }
      },
      {
        "two": "b",
        "nested": {
          "b": 2
        }
      }
    ]
  },
  "resources": [],
  "outputs": {
    "firstOutput": {
      "type": "object",
      "value": "[shallowMerge(variables('firstArray'))]"
    },
    "secondOutput": {
      "type": "object",
      "value": "[shallowMerge(variables('secondArray'))]"
    }
  }
}

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

Nom Type Valeur
firstOutput object {"one":"a","two":"c"}
secondOutput object {"one":"a","nested":{"b":2},"two":"b"}

firstOutput montre que les propriétés des objets de fusion sont combinées en un nouvel objet. S’il existe des propriétés en conflit (par exemple, des propriétés portant le même nom), la propriété du dernier objet fusionné est généralement prioritaire.

secondOutput montre que la fusion superficielle ne fusionne pas de manière récursive ces objets imbriqués. Au lieu de cela, l’objet imbriqué entier est remplacé par la propriété correspondante de l’objet de fusion.

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 tous 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, de manière récursive, tous les tableaux et objets imbriqués à l'intérieur de ceux-ci. 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 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