Types de données dans Bicep

Cet article décrit les types de données pris en charge dans Bicep. Pour définir des types de données personnalisés, consultez Types de données définis par l’utilisateur.

N'importe lequel

Avec Bicep version v0.38.3 et ultérieure, le any type dans Bicep est un type permissif qui désactive la vérification du type au moment de la compilation pour le symbole associé. Une valeur de type any peut contenir des données de n’importe quel type, y compris string, , intbool, arrayobjectou des expressions complexes.

param foo any
output bar any = foo

Dans l’exemple précédent, foo peut accepter n’importe quel type de valeur et bar génère la même valeur que foo son type.

Étant donné que any contourne la sécurité de type de Bicep, elle ne doit être utilisée que lorsque le type exact ne peut pas être déterminé à l’avance. Par exemple, lors de la transmission de données via un module qui gère plusieurs formes de données ou lors de l’utilisation d’une entrée JSON non typée.

L’utilisation any rend Bicep moins prévisible et peut entraîner des erreurs d’exécution. Si possible, préférez des types spécifiques ou une union de types attendus pour conserver la validation et la prise en charge d’IntelliSense. La règle No explicit Any linter permet d’identifier et de décourager l’utilisation du any type dans les fichiers Bicep.

Tableaux

Un tableau dans Bicep est une collection ordonnée de valeurs, telles que des chaînes, des entiers, des objets ou même d’autres tableaux, couramment utilisés pour regrouper des éléments connexes tels que des noms de ressources, des paramètres de configuration ou des paramètres. Les tableaux sont utiles pour organiser les données de déploiement, passer des listes à des ressources et effectuer une itération sur plusieurs valeurs.

Les tableaux dans Bicep sont immuables. Une fois déclaré, leur contenu ne peut pas être modifié. Pour « modifier » un tableau, créez un tableau à l’aide de fonctions telles que concat, mapou filter.

param usLocations array = [
  'eastus'
  'westus2'
]

param euroLocations string[] = [
  'northeurope'
  'westeurope'
]

param numbers int[] = [
  1
  2
  3
]

Vous pouvez déclarer des tableaux dans Bicep à l’aide d’une syntaxe à ligne unique ou multiligne. Les déclarations de tableau à plusieurs lignes nécessitent Bicep CLI version 0.7.X ou ultérieure.

var multiLineArray = [
  'abc'
  'def'
  'ghi'
]

var singleLineArray = ['abc', 'def', 'ghi']

var mixedArray = ['abc', 'def'
    'ghi']

Les tableaux à ligne unique utilisent des virgules (,) pour séparer les valeurs. Les tableaux à plusieurs lignes n’utilisent pas de virgules entre les valeurs. Vous pouvez combiner des déclarations monolignes et multilignes en fonction des besoins.

Chaque élément de tableau peut être de n’importe quel type. Vous pouvez avoir un tableau où tous les éléments sont du même type de données ou un tableau qui contient des types de données différents.

var integerArray = [
  1
  2
  3
]

var mixedArray = [
  resourceGroup().name
  1
  true
  'example string'
]

var arrayOfObjects = [
  { name: 'dev', size: 1 }
  { name: 'prod', size: 2 }
]

Dans Bicep, les tableaux sont de base zéro. Vous pouvez accéder aux éléments par index :

var exampleArray = [1, 2, 3]
output firstElement int = exampleArray[0] // 1
output thirdElement int = exampleArray[2] // 3

var index = 1
output secondElement int = exampleArray[index] // 2

À compter de Bicep CLI version 0.34.x, vous pouvez utiliser la array[^index] syntaxe pour accéder aux éléments à partir de la fin d’un tableau : ^1 fait référence au dernier élément, ^2 au second au dernier, et ainsi de suite.

var exampleArray = [1, 2, 3]

output lastElement int = exampleArray[^1] // 3
output secondToLastElement int = exampleArray[^2] // 2

Si vous accédez à un index hors limites, vous obtenez une erreur :

The language expression property array index 'x' is out of bounds

Pour éviter l’exception hors limites, utilisez l’opérateur ou logique, comme indiqué dans l’exemple suivant :

param emptyArray array = []
param numberArray array = [1, 2, 3]

output foo bool = empty(emptyArray) || emptyArray[0] == 'bar'
output bar bool = length(numberArray) <= 3 || numberArray[3] == 4

Opérateurs liés au tableau

• Utilisez des opérateurs de comparaison pour comparer deux tableaux.
• Utilisez l’accesseur Index pour obtenir un élément à partir d’un tableau.
• Utilisez l’opérateur safe-dereference pour accéder aux éléments d’un tableau.
• Utilisez Spread pour fusionner des tableaux.

Fonctions liées au tableau

• Consultez les fonctions array.
• Consultez les fonctions Lambda.

Valeurs booléennes

Lorsque vous spécifiez des valeurs booléennes, utilisez true ou false. N’entourez pas la valeur de guillemets.

param exampleBool bool = true

Opérateurs booléens

• Utilisez des opérateurs de comparaison pour comparer des valeurs booléennes.
• Consultez les opérateurs logiques.

Fonctions booléennes

Voir la fonction logique

Entiers

Lorsque vous spécifiez des valeurs entières, n’utilisez pas de guillemets.

param exampleInt int = 1

Les entiers Bicep sont des entiers 64 bits. Lorsqu’ils sont passés en tant que paramètres inline, l’outil de développement logiciel (SDK) ou de ligne de commande que vous utilisez pour le déploiement peut limiter la plage de valeurs. Par exemple, lorsque vous utilisez PowerShell pour déployer Bicep, les types entiers peuvent aller de -2147483648 à 2147483647. Pour éviter cette limitation, spécifiez des valeurs entières volumineuses dans un fichier de paramètres. Les types de ressources appliquent leurs propres limites aux propriétés d’entiers.

Bicep prend en charge un type littéral entier qui fait référence à une valeur spécifique qui est un entier exact. Dans l’exemple suivant, 1 il s’agit d’un type littéral entier et foo ne peut être attribué que la valeur 1 et aucune autre valeur.

output foo 1 = 1

Vous pouvez déclarer un type littéral entier inline, comme illustré dans l’exemple précédent ou dans une type instruction.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

Dans l’exemple précédent, l’affectation à des résultats d’une 2 : « Valeur de type bar attendue, mais la valeur fournie est de type ».12

L’exemple suivant utilise un type littéral entier avec un type union :

output bar 1 | 2 | 3 = 3

Les formats à virgule flottante, décimale ou binaire ne sont actuellement pas pris en charge.

Opérateurs liés à l’entier

• Consultez les opérateurs de comparaison.
• Voir opérateurs numériques.

Fonctions liées à l’entier

Consultez les fonctions numériques.

Objets

Les objets commencent par une accolade ouvrante ({) et se terminent par une accolade fermante (}). Dans Bicep, vous pouvez déclarer un objet dans une seule ligne ou dans plusieurs lignes. Chaque propriété d’un objet se compose d’une clé et d’une valeur. La clé et la valeur sont séparées par un signe deux-points (:). Un objet accepte toute propriété de n’importe quel type. Les virgules (,) sont utilisées entre les propriétés pour les déclarations à une seule ligne, mais elles ne sont pas utilisées entre les propriétés pour les déclarations à plusieurs lignes. Vous pouvez combiner et mettre en correspondance des déclarations monolignes et à plusieurs lignes. La déclaration à plusieurs lignes nécessite Bicep CLI version 0.7.X ou ultérieure.

param singleLineObject object = {name: 'test name', id: '123-abc', isCurrent: true, tier: 1}

param multiLineObject object = {
  name: 'test name'
  id: '123-abc'
  isCurrent: true
  tier: 1
}

param mixedObject object = {name: 'test name', id: '123-abc', isCurrent: true
    tier: 1}

Dans Bicep, les guillemets sont éventuellement autorisés sur les clés de propriété d’objet :

var test = {
  'my - special. key': 'value'
}

Dans l’exemple précédent, les guillemets sont utilisés lorsque les clés de propriété d’objet contiennent des caractères spéciaux. Par exemple, l’espace, -ou .. L’exemple suivant montre comment utiliser l’interpolation dans les clés de propriété de l’objet.

var stringVar = 'example value'
var objectVar = {
  '${stringVar}': 'this value'
}

Les accesseurs de propriété sont utilisés pour accéder aux propriétés d’un objet. Ils sont construits à l’aide de l’opérateur . .

var a = {
  b: 'Dev'
  c: 42
  d: {
    e: true
  }
}

output result1 string = a.b // returns 'Dev'
output result2 int = a.c // returns 42
output result3 bool = a.d.e // returns true

Vous pouvez utiliser des accesseurs de propriétés avec n’importe quel objet, y compris les paramètres et les variables des types d’objets et des littéraux d’objet. Un accesseur de propriété utilisé sur une expression d’un type nonobject est une erreur.

Vous pouvez également utiliser la syntaxe [] pour accéder à une propriété. L’exemple suivant renvoie Development.

var environmentSettings = {
  dev: {
    name: 'Development'
  }
  prod: {
    name: 'Production'
  }
}

output accessorResult string = environmentSettings['dev'].name

Dans JSON, un objet est une collection non ordonnée de zéro ou plusieurs paires clé ou valeur. L’ordre peut être différent en fonction des implémentations. Par exemple, la fonction Bicep items() trie les objets par ordre alphabétique. Dans d’autres endroits, vous pouvez conserver l’ordre d’origine. En raison de ce nondéterminisme, évitez d’effectuer des hypothèses sur l’ordre des clés d’objet lorsque vous écrivez du code, qui interagit avec les paramètres de déploiement et les sorties.

Vous obtenez l’erreur suivante lorsque vous accédez à une propriété inexistante d’un objet :

The language expression property 'foo' doesn't exist

Pour éviter l’exception, vous pouvez utiliser l’opérateur And logical, comme illustré dans l’exemple suivant :

param objectToTest object = {
  one: 1
  two: 2
  three: 3
}

output bar bool = contains(objectToTest, 'four') && objectToTest.four == 4

Opérateurs liés à l’objet

• Utilisez des opérateurs de comparaison pour comparer des objets.
• Utilisez l’accesseur Index pour obtenir une propriété à partir d’un objet.
• Utilisez l’opérateur Safe-dereference pour accéder aux membres de l’objet.
• Utilisez Spread pour fusionner des objets.

Fonctions liées à l’objet

Consultez les fonctions Object.

Chaînes

Dans Bicep, les chaînes sont marquées avec des guillemets simples et vous devez les déclarer sur une seule ligne. Tous les caractères Unicode avec des points de code entre 0 et 10FFFF sont autorisés.

param exampleString string = 'test value'

Le tableau suivant répertorie l’ensemble de caractères réservés que vous devez échapper à l’aide d’une barre oblique inverse (\) caractère :

// evaluates to "what's up?"
var myVar = 'what\'s up?'

Bicep prend en charge un type littéral de chaîne qui fait référence à une valeur de chaîne spécifique. Dans l’exemple suivant, red il s’agit d’un type littéral de chaîne. Vous ne pouvez affecter la valeur red qu’à redColor.

output redColor 'red' = 'red'

Vous pouvez déclarer un type littéral de chaîne inline, comme indiqué dans l’exemple précédent ou dans une type instruction.

type redColor = 'red'

output colorRed redColor = 'red'
output colorBlue redColor = 'blue'

Dans l’exemple précédent, l’affectation à des résultats d’une blue : « Valeur de type colorBlue attendue, mais la valeur fournie est de type ».redblue

L’exemple suivant montre un type littéral de chaîne utilisé avec un type union :

type direction = 'north' | 'south' | 'east' | 'west'

output west direction = 'west'
output northWest direction = 'northwest'

Toutes les chaînes dans Bicep prennent en charge l’interpolation. Pour injecter une expression, placez-la entre ${ et }. Les expressions référencées ne peuvent pas s’étendre sur plusieurs lignes.

var storageName = 'storage${uniqueString(resourceGroup().id)}'

Chaînes à lignes multiples

Dans Bicep, les chaînes à plusieurs lignes sont définies entre trois guillemets simples (''') suivis éventuellement d’une nouvelle ligne (la séquence d’ouverture) et de trois guillemets simples (''' est la séquence fermante). Les caractères entrés entre la séquence d’ouverture et de fermeture sont lus en détail. L’échappement n’est pas nécessaire ou possible.

// evaluates to "hello!"
var myVar = '''hello!'''

// evaluates to "hello!" because the first newline is skipped
var myVar2 = '''
hello!'''

// evaluates to "hello!\n" because the final newline is included
var myVar3 = '''
hello!
'''

// evaluates to "  this\n    is\n      indented\n"
var myVar4 = '''
  this
    is
      indented
'''

// evaluates to "comments // are included\n/* because everything is read as-is */\n"
var myVar5 = '''
comments // are included
/* because everything is read as-is */
'''

// evaluates to "interpolation\nis ${blocked}"
// note ${blocked} is part of the string, and is not evaluated as an expression
var myVar6 = '''interpolation
is ${blocked}'''

Opérateurs liés à des chaînes

• Consultez les opérateurs de comparaison.

Fonctions liées aux chaînes

• Consultez les fonctions string.

Types union

Dans Bicep, un type union permet la création d’un type combiné qui se compose d’un ensemble de sous-types. Une affectation est valide si l’une des affectations de sous-type individuelles est autorisée. Le | caractère sépare les sous-types individuels qui utilisent une or condition. Par exemple, la syntaxe a | b signifie qu’une affectation valide peut être soit a soit .b Les types union étant traduits en contrainte de valeur autorisée dans Bicep, seuls les littéraux sont autorisés comme membres. Les unions peuvent comporter n’importe quel nombre d’expressions type littérales.

type color = 'Red' | 'Blue' | 'White'
type trueOrFalse = 'true' | 'false'
type permittedIntegers = 1 | 2 | 3
type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'}
type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]

Les unions de type doivent être réductibles à un type Azure Resource Manager unique, tel que string, intou bool. Sinon, vous obtenez le code d’erreur BCP294 . Par exemple :

type foo = 'a' | 1

Vous pouvez utiliser n’importe quel type d’expression comme sous-type dans une déclaration de type union (entre | les caractères). Par exemple, les exemples suivants sont tous valides :

type foo = 1 | 2
type bar = foo | 3
type baz = bar | (4 | 5) | 6

Type de données union avec étiquette personnalisée

Bicep prend en charge un type de données union personnalisé, qui représente une valeur qui peut être l’un de plusieurs types. Pour déclarer un type de données union personnalisé, vous pouvez utiliser un @discriminator() décorateur. Bicep CLI version 0.21.X ou ultérieure est nécessaire pour utiliser ce décorateur. La syntaxe est :

@discriminator('<property-name>')

L’élément décoratif discriminant prend un seul paramètre, qui représente un nom de propriété partagée parmi tous les membres de l’union. Ce nom de propriété doit être un littéral de chaîne obligatoire sur tous les membres et respecte la casse. Les valeurs de la propriété discriminée sur les membres de l’union doivent être uniques d’une manière ne respectant pas la casse.

type FooConfig = {
  type: 'foo'
  value: int
}

type BarConfig = {
  type: 'bar'
  value: bool
}

@discriminator('type')
param ServiceConfig  FooConfig | BarConfig | { type: 'baz', *: string } = { type: 'bar', value: true }

La valeur du paramètre est validée en fonction de la valeur de propriété discriminée. Par exemple, dans l’exemple précédent, si le serviceConfig paramètre est de type foo, il est validé à l’aide du FooConfig type. De même, si le paramètre est de type bar, il est validé à l’aide du BarConfig type. Ce modèle s’applique également à d’autres types.

Le type d’union présente certaines limitations :

• Les types union doivent être réductibles à un seul type Azure Resource Manager. La définition suivante n’est pas valide :

  type foo = 'a' | 1
  

• Seuls les littéraux sont autorisés en tant que membres.

• Tous les littéraux doivent être du même type de données primitif (par exemple, toutes les chaînes ou tous les entiers).

Vous pouvez utiliser la syntaxe de type union dans les types de données définis par l’utilisateur.

Types Nullable

Vous pouvez rendre nullable de type primitif ou complexe en ajoutant un ? au nom de type. Cela permet au paramètre, à la variable ou à la sortie d’accepter null comme valeur valide. Par exemple :

output description string? = null
output config object? = null
output optionalValue int? = null

Sécuriser les chaînes et objets

Les chaînes sécurisées utilisent le même format que la chaîne et les objets sécurisés utilisent le même format que l’objet. Avec Bicep, vous ajoutez le @secure()décorateur à une chaîne ou un objet.

Lorsque vous définissez un paramètre (ou une sortie) sur une chaîne sécurisée ou un objet sécurisé, la valeur du paramètre (ou la sortie) n’est pas enregistrée dans l’historique de déploiement ou journalisée. Toutefois, lors de l’utilisation de l’indicateur pendant le --debug déploiement, les valeurs sécurisées sont consignées en texte clair. Si vous définissez cette valeur sécurisée sur une propriété qui ne s’attend pas à une valeur sécurisée, la valeur n’est pas protégée. Par exemple, si vous définissez une chaîne sécurisée sur une balise, cette valeur est stockée sous forme de texte brut. Utilisez des chaînes sécurisées pour les mots de passe et les secrets.

L’exemple suivant présente deux paramètres sécurisés :

@secure()
param password string

@secure()
param configValues object

Pour plus d’informations, consultez Paramètres sécurisés et sorties sécurisées.

Attribution de type de données

Dans Bicep, vous pouvez affecter une valeur d’un type (type source) à un autre type (type cible). Le tableau suivant indique le type source (répertorié horizontalement) que vous pouvez ou ne pouvez pas affecter à quel type cible (répertorié verticalement). Dans la table, X signifie assignable, un espace vide signifie non assignable, et ? signifie uniquement si les types sont compatibles.

Étapes suivantes

Pour en savoir plus sur la structure et la syntaxe de Bicep, consultez la structure et la syntaxe des fichiers Bicep.