Fonctions d’objet pour Bicep

  • Article

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

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 :

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 :

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

empty

empty(itemToTest)

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

Espace de noms : sys.

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.

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

output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(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.

Espace de noms : sys.

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 Les valeur supplémentaires à utiliser pour rechercher des éléments communs.

Valeur retournée

Tableau ou objet avec les éléments communs.

Exemple

L’exemple suivant indique comment utiliser l’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 :

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.

Espace de noms : sys.

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.

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

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

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 :

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.

Espace de noms : sys.

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 :

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 :

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

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

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 retournée

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 elle fusionne également de manière récursive tous les objets imbriqués dans ceux-ci. 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 :

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 :

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 :

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 :

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