Fonctions d’objet pour Bicep

Cet article décrit les fonctions Bicep pour l’utilisation d’objets.

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.

Espace de noms : sys.

Paramètres

Valeur retournée

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

Exemple

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

param stringToTest string = 'OneTwoThree'
param objectToTest object = {
  one: 'a'
  two: 'b'
  three: 'c'
}
param arrayToTest array = [
  'one'
  'two'
  'three'
]

output stringTrue bool = contains(stringToTest, 'e')
output stringFalse bool = contains(stringToTest, 'z')
output objectTrue bool = contains(objectToTest, 'one')
output objectFalse bool = contains(objectToTest, 'a')
output arrayTrue bool = contains(arrayToTest, 'three')
output arrayFalse bool = contains(arrayToTest, 'four')

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

empty

empty(itemToTest)

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

Espace de noms : sys.

Paramètres

Valeur retournée

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

Exemple

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

param testArray array = []
param testObject object = {}
param testString string = ''
param testNullString string?

output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)
output stringNull bool = empty(testNullString)

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

intersection

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

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

Espace de noms : sys.

Paramètres

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 :

param firstObject object = {
  one: 'a'
  two: 'b'
  three: 'c'
}
param secondObject object = {
  one: 'a'
  two: 'z'
  three: 'c'
}
param firstArray array = [
  'one'
  'two'
  'three'
]
param secondArray array = [
  'two'
  'three'
]

output objectOutput object = intersection(firstObject, secondObject)
output arrayOutput array = intersection(firstArray, secondArray)

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

items

items(object)

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

Espace de noms : sys.

Paramètres

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.

var entities = {
  item002: {
    enabled: false
    displayName: 'Example item 2'
    number: 200
  }
  item001: {
    enabled: true
    displayName: 'Example item 1'
    number: 300
  }
}

var modifiedListOfEntities = [for entity in items(entities): {
  key: entity.key
  fullName: entity.value.displayName
  itemEnabled: entity.value.enabled
}]

output modifiedResult array = 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.

var entities = {
  item002: {
    enabled: false
    displayName: 'Example item 2'
    number: 200
  }
  item001: {
    enabled: true
    displayName: 'Example item 1'
    number: 300
  }
}

var entitiesArray = items(entities)

output itemsResult array = 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.

Espace de noms : sys.

Paramètres

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

Remarques

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

Exemple

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

param jsonEmptyObject string = 'null'
param jsonObject string = '{\'a\': \'b\'}'
param jsonString string = '\'test\''
param jsonBoolean string = 'true'
param jsonInt string = '3'
param jsonArray string = '[[1,2,3]]'
param concatValue string = 'demo value'

output emptyObjectOutput bool = empty(json(jsonEmptyObject))
output objectOutput object = json(jsonObject)
output stringOutput string =json(jsonString)
output booleanOutput bool = json(jsonBoolean)
output intOutput int = json(jsonInt)
output arrayOutput array = json(jsonArray)
output concatObjectOutput object = json(concat('{"a": "', concatValue, '"}'))

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

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.

Espace de noms : sys.

Paramètres

Valeur retournée

Un entier.

Exemple

L’exemple suivant montre comment utiliser length avec un tableau et une chaîne :

param arrayToTest array = [
  'one'
  'two'
  'three'
]
param stringToTest string = 'One Two Three'
param objectToTest object = {
  propA: 'one'
  propB: 'two'
  propC: 'three'
  propD: {
      'propD-1': 'sub'
      'propD-2': 'sub'
  }
}

output arrayLength int = length(arrayToTest)
output stringLength int = length(stringToTest)
output objectLength int = length(objectToTest)

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

objectKeys

objectKeys(object)

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

Espace de noms : sys.

Paramètres

Valeur retournée

Tableau.

Exemple

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

var obj = { a: 1, b: 2 }

output keyArray array = objectKeys(obj)

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

keyArray retourne une liste de clés de l’objet d’entrée.

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 profondément fusionnés. Au lieu de cela, ils sont entièrement remplacés par la propriété correspondante de l’objet de fusion.

Espace de noms : sys.

Paramètres

Valeur retournée

Objet.

Exemple

L'exemple suivant montre comment utiliser shallowMerge :

var firstArray = [{ one: 'a' }, { two: 'b' }, { two: 'c'}]
var secondArray = [{ one: 'a', nested: {a: 1, nested: {c: 3}} }, { two: 'b', nested: {b: 2}}]

output firstOutput object = shallowMerge(firstArray)
output secondOutput object = shallowMerge(secondArray)

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

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 (autrement dit, 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.

Espace de noms : sys.

Paramètres

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 tout autre paramètre. 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 montre comment utiliser union avec les tableaux et les objets :

param firstObject object = {
  one: 'a'
  two: 'b'
  three: 'c1'
}

param secondObject object = {
  three: 'c2'
  four: 'd'
  five: 'e'
}

param firstArray array = [
  'one'
  'two'
  'three'
]

param secondArray array = [
  'three'
  'four'
  'two'
]

output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)

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

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

var firstObject = {
  property: {
    one: 'a'
    two: 'b'
    three: 'c1'
  }
  nestedArray: [
    1
    2
  ]
}
var secondObject = {
  property: {
    three: 'c2'
    four: 'd'
    five: 'e'
  }
  nestedArray: [
    3
    4
  ]
}
var firstArray = [
  [
    'one'
    'two'
  ]
  [
    'three'
  ]
]
var secondArray = [
  [
    'three'
  ]
  [
    'four'
    'two'
  ]
]

output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)

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

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 fichier Bicep, consultez Comprendre la structure et la syntaxe des fichiers Bicep.