Partager via

Types de données dans Bicep

  • Article

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.

Tableaux

Les tableaux commencent par un crochet ouvrant ([) et se terminent par un crochet fermant (]). Dans Bicep, vous pouvez déclarer un tableau dans une seule ligne ou dans plusieurs lignes. Les virgules (,) sont utilisées entre les valeurs dans les déclarations à une seule ligne, mais elles ne sont pas utilisées dans 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.

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 différents types.

var integerArray = [
  1
  2
  3
]

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

Les tableaux dans Bicep sont basés sur 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 entiers sont autorisés uniquement sur l’expression des types de tableaux.

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, utilisez l’opérateur ou logique, 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
  • 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.

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

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 erreur BCP033 : « Valeur de type 1 attendue, mais la valeur fournie est de type 2».bar 2

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.

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

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 :

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 Représente x une valeur de point de code hexadécimal entre 0 et 10FFFF (à la fois inclusive). Les zéros non significatifs sont autorisés. Les points de code ci-dessus FFFF sont émis en tant que paire de substitution.
\$ $ Échappement uniquement quand suivi de {. 
// 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 erreur BCP033 : « Valeur de type red attendue, mais la valeur fournie est de type blue».colorBlue blue

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.

Remarque

L’analyseur Bicep lit tous les caractères comme c’est le cas. Selon les fin de ligne de votre fichier Bicep, les lignes de newline sont interprétées comme l’une ou l’autre \r\n \n.

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

Les chaînes à plusieurs lignes qui contiennent ''' 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é 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 quelle expression de type 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 un type de données union personnalisé, qui est utilisé pour représenter 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 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 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.

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

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.

Types any error 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 ? ?

Contenu connexe

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