Types de données dans Bicep

Article
08/20/2024

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

Types pris en charge

Dans un fichier Bicep, vous pouvez utiliser les types de données suivants :

array
bool
int
object
secureObject : indiqué par un élément décoratif dans Bicep
secureString : indiqué par un élément décoratif dans Bicep
string

Tableaux

Les tableaux commencent par un crochet ouvrant ([) et se terminent par un crochet fermant (]). Dans Bicep, il est possible de déclarer un tableau dans une ou plusieurs lignes. Les virgules (,) sont utilisées entre les valeurs des déclarations monolignes, mais pas utilisées dans les déclarations à plusieurs lignes. Vous pouvez combiner et faire correspondre des déclarations monolignes et à plusieurs lignes. La déclaration à plusieurs lignes nécessite Bicep CLI version 0.7.X ou ultérieure.

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

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

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

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.

L'exemple suivant montre un tableau d'entiers et un tableau de types différents.

var integerArray = [
  1
  2
  3
]

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

Dans Bicep, les tableaux sont de base zéro. Dans l’exemple suivant, l’expression exampleArray[0] prend la valeur 1 et l’expression exampleArray[2] prend la valeur 3. L’index de l’indexeur peut être une autre expression. L’expression exampleArray[index] prend la valeur 2. Les indexeurs d’entier sont autorisés uniquement sur une expression de type tableau.

var index = 1

var exampleArray = [
  1
  2
  3
]

Vous obtenez l’erreur suivante lorsque l’index est hors limites :

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

Pour éviter cette exception, vous pouvez utiliser l’opérateur logique Or , comme illustré 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

valeurs booléennes

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

param exampleBool bool = true

Entiers

Quand 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’elles sont passées en tant que paramètres inline, la plage de valeurs peut être limitée par le SDK ou l’outil en ligne de commande que vous utilisez pour le déploiement. Par exemple, si vous utilisez PowerShell pour déployer un fichier Bicep, les types d’entiers peuvent être compris entre -2147483648 et 2147483647. Pour éviter cette limite, spécifiez des valeurs entières élevées dans un fichier de paramètres. Les types de ressources appliquent leurs propres limites aux propriétés d’entiers.

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

output foo 1 = 1

Un type littéral entier peut être déclaré 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 de 2 à la barre génère une erreur BCP033 : une valeur de type « 1 » attendue, mais la valeur fournie est de type « 2 ».

L’exemple suivant montre l’utilisation du type littéral entier avec le type union :

output bar 1 | 2 | 3 = 3

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

Objets

Les objets commencent par une accolade ouvrante ({) et se terminent par une accolade fermante (}). Dans Bicep, il est possible de déclarer un objet dans une ou 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 des déclarations monolignes, mais 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 autorisés de manière facultative sur les clés de propriété de l’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é de l’objet contiennent des caractères spéciaux. Par exemple, une 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

Les accesseurs de propriété peuvent être utilisés avec n’importe quel objet, y compris les paramètres et les variables des types d’objets et des littéraux d’objet. L’utilisation d’un accesseur de propriété sur une expression de type hors objet 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 paires clé/valeur (zéro ou plus). 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.

Vous obtenez l’erreur suivante lors de l’accès à 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 logique And comme indiqué dans l’exemple suivant :

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

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

Chaînes

Dans Bicep, les chaînes sont marquées avec des guillemets simples et doivent être déclarées 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 liste l’ensemble de caractères réservés qui doivent être placés dans une séquence d’échappement avec une barre oblique inverse (\) :

Séquence d'échappement	Valeur représentée	Notes
`\\`	`\`
`\'`	`'`
`\n`	saut de ligne (LF)
`\r`	retour chariot (CR)
`\t`	caractère de tabulation
`\u{x}`	Point de code Unicode `x`	x représente une valeur de point de code hexadécimale entre 0 et 10FFFF (les deux inclus). Les zéros non significatifs sont autorisés. Les points de code au-dessus de FFFF sont émis comme paire de substitution.
`\$`	`$`	Échappement uniquement quand suivi de `{`.

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

Bicep prend en charge le type littéral de chaîne qui fait référence à une valeur de chaîne spécifique. Dans l’exemple suivant, le rouge est un type littéral de chaîne, redColor ne peut être affecté qu’à la valeur rouge et aucune autre valeur.

output redColor 'red' = 'red'

Un type littéral de chaîne peut être déclaré 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 de bleu à colorBlue entraîne une erreur BCP033 : une valeur de type « rouge » attendue, mais la valeur fournie est de type « blue ».

L’exemple suivant montre l’utilisation du type littéral de chaîne avec le 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 multilignes sont définies entre trois guillemets simples (''') suivis éventuellement d’une nouvelle ligne (séquence d’ouverture) et trois guillemets simples (''') (séquence de fermeture). Les caractères entrés entre les séquences d’ouverture et de fermeture sont lus textuellement, et aucun échappement n’est nécessaire ni possible.

Notes

Étant donné que l’analyseur Bicep lit tous les caractères tels quels, selon les fins de ligne de votre fichier Bicep, les nouvelles lignes peuvent être interprétées comme \r\n ou \n.

Actuellement, l’interpolation n’est pas prise en charge dans les chaînes multilignes. En raison de cette limitation, vous devrez peut-être utiliser la fonction concat au lieu de l’interpolation.

Les chaînes multilignes contenant ''' ne sont pas prises en charge.

// 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}'''

Types union

Dans Bicep, un type union permet la création d’un type combiné constitué 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 à l’aide d’une ou d’une condition. Par exemple, la syntaxe 'a' | 'b' signifie qu’une affectation valide peut être 'a' ou '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 ARM unique, tel que « string », « int » ou « bool ». Sinon, vous obtenez le code d’erreur BCP294 . Par exemple :

type foo = 'a' | 1

Toute expression de type peut être utilisée comme sous-type dans une déclaration de type union (entre | 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 le type de données union étiqueté personnalisé, qui est utilisé pour représenter une valeur qui peut être l’un de plusieurs types différents. Pour déclarer un type de données union étiqueté personnalisé, vous pouvez utiliser un @discriminator() décorateur. Bicep CLI version 0.21.X ou ultérieure est nécessaire pour utiliser cet élément décoratif. 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 paramètre serviceConfig est de type foo, il est validé à l’aide du type FooConfig. De même, si le paramètre est de type barre, il est validé à l’aide du type BarConfig . Ce modèle s’applique également à d’autres types.

Il existe certaines limitations avec le type union.

Les types Union doivent être réductibles à un seul type Azure Resource Manager (ARM). 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).

La syntaxe de type union peut être utilisée dans les types de données définis par l’utilisateur.

Sécuriser les chaînes et objets

La chaîne sécurisée utilise le même format que la chaîne, et l’objet sécurisé utilise 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 sur une chaîne sécurisée ou un objet sécurisé, la valeur du paramètre n’est pas enregistrée dans l’historique de déploiement et n’est pas consignée. Toutefois, si vous définissez cette valeur sécurisée sur une propriété qui n’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

Attribution de type de données

Dans Bicep, une valeur d’un type (type source) peut être attribuée à un autre type (type cible). Le tableau suivant indique le type source (indiqué horizontalement) qui peut ou ne peut pas être attribué au type cible (indiqué verticalement). Dans le tableau, X signifie « Peut être attribué », l’espace vide signifie « Ne peut pas être attribué » et ? signifie « Uniquement si les types sont compatibles ».

Types	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	ressource nommée	module nommé	`scope`
`any`	X	X	X	X	X	X	X	X	X	X	X
`error`
`string`	X	X
`number`	X		X	X
`int`	X			X
`bool`	X				X
`null`	X					X
`object`	X						X
`array`	X							X
`resource`	X								X
`module`	X									X
`scope`											?
ressource nommée	X						?		?
module nommé	X						?			?

Étapes suivantes

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

Partager via