Tipos de datos de Bicep

Artigo
08/20/2024

En este artículo se describen los tipos de datos admitidos en Bicep. Para definir tipos de datos personalizados, vea Tipos de datos definidos por el usuario.

Tipos admitidos

Dentro de Bicep, puede usar estos tipos de datos:

array
bool
int
object
secureObject: indicado por decorador en Bicep
secureString: indicado por decorador en Bicep
string

Matrices

Las matrices comienzan con un corchete de apertura ([) y terminan con un corchete de cierre (]). En Bicep, una matriz se puede declarar en una sola línea o en varias. Las comas (,) se usan entre valores en declaraciones de una sola línea, pero no se usan en declaraciones de varias líneas. Puede mezclar y coincidir con declaraciones de una sola línea y de varias líneas. La declaración de varias líneas necesita la versión 0.7X o posterior de la CLI de Bicep.

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

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

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

Cada elemento de matriz puede ser de cualquier tipo. Puede tener una matriz en la que cada elemento sea del mismo tipo de datos o una matriz que contenga tipos de datos diferentes.

En el ejemplo siguiente se muestra una matriz de enteros y una matriz de otros tipos.

var integerArray = [
  1
  2
  3
]

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

Las matrices de Bicep son de base cero. En el ejemplo siguiente, la expresión exampleArray[0] se evalúa en 1 y exampleArray[2] se evalúa en 3. El índice del indexador puede ser otra expresión. La expresión exampleArray[index] se evalúa en 2. Los indexadores enteros solo se permiten en la expresión de tipos de matriz.

var index = 1

var exampleArray = [
  1
  2
  3
]

Obtiene el siguiente error cuando el índice está fuera de los límites:

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

Para evitar esta excepción, puede usar el operador lógico Or como se muestra en el ejemplo siguiente:

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

Valores booleanos

Al especificar valores booleanos, use true o false. No incluya el valor entre comillas.

param exampleBool bool = true

Enteros

Al especificar valores enteros, no use comillas.

param exampleInt int = 1

Los enteros de Bicep son enteros de 64 bits. Cuando se pasan como parámetros insertados, el intervalo de valores puede estar limitado por el SDK o la herramienta de línea de comandos que se usa para la implementación. Por ejemplo, al usar PowerShell para implementar Bicep, los tipos de enteros pueden oscilar entre -2147483648 y 2147483647. Para evitar esta limitación, especifique valores enteros grandes en un archivo de parámetros. Los tipos de recursos aplican sus propios límites para las propiedades de enteros.

Bicep admite el tipo literal entero que hace referencia a un valor específico que es un entero exacto. En el ejemplo siguiente, 1 es un tipo literal entero, foo solo se puede asignar el valor 1 y ningún otro valor.

output foo 1 = 1

Un tipo literal entero se puede declarar en línea, como se muestra en el ejemplo anterior o en una type instrucción .

type oneType = 1

output foo oneType = 1
output bar oneType = 2

En el ejemplo anterior, la asignación de 2 a la barra produce un error BCP033: se esperaba un valor de tipo "1", pero el valor proporcionado es del tipo "2".

En el ejemplo siguiente se muestra el uso del tipo literal entero con tipo de unión:

output bar 1 | 2 | 3 = 3

Actualmente no se admiten formatos de número de punto flotante, decimal o binario.

Objetos

Los objetos comienzan con una llave de apertura ({) y terminan con una llave de cierre (}). En Bicep, un objeto se puede declarar en una sola línea o en varias. Cada propiedad de un objeto consta de una clave y un valor. La clave y el valor están separados por dos puntos (:). Un objeto permite cualquier propiedad de cualquier tipo. Las comas (,) se usan entre propiedades para declaraciones de una sola línea, pero no se usan entre propiedades para declaraciones de varias líneas. Puede mezclar y hacer coincidir declaraciones de una sola línea y de varias. La declaración de varias líneas necesita la versión 0.7X o posterior de la CLI de Bicep.

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}

En Bicep, las comillas se permiten opcionalmente en las claves de propiedad de objeto:

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

En el ejemplo anterior, las comillas se usan cuando las claves de propiedad del objeto contienen caracteres especiales. Por ejemplo, espacio, "-" o ".". En el ejemplo siguiente se muestra cómo usar la interpolación en claves de propiedad de objeto.

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

Los descriptores de acceso de propiedad se usan para acceder a las propiedades de un objeto. Se construyen mediante el operador ..

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

Los descriptores de acceso de propiedad se pueden usar con cualquier objeto, incluidos los parámetros y las variables de tipos de objeto y literales de objeto. Usar un descriptor de acceso de propiedad en una expresión que no sea de tipo objeto es un error.

También puede usar la sintaxis [] para acceder a una propiedad. El siguiente ejemplo devuelve Development.

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

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

En JSON, un objeto es una colección desordenada de cero o más pares clave-valor. El orden puede ser diferente en función de las implementaciones. Por ejemplo, la función Bicep items() ordena los objetos por orden alfabético. En otros lugares, se puede conservar la ordenación original. Debido a este no determinismo, evite realizar suposiciones sobre el orden de las claves de objeto al escribir código, que interactúa con los parámetros y salidas de implementación.

Se obtiene el siguiente error al obtener acceso a una propiedad no existente de un objeto:

The language expression property 'foo' doesn't exist

Para evitar la excepción, puede usar el operador lógico And como se muestra en el ejemplo siguiente:

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

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

Cadenas

En Bicep, las cadenas se marcan con comillas simples y se deben declarar en una sola línea. Se permiten todos los caracteres Unicode con puntos de código entre 0 y 10FFFF.

param exampleString string = 'test value'

En la tabla siguiente se muestra el conjunto de caracteres reservados que se deben escapar mediante una barra diagonal inversa (\):

Secuencia de escape	Valor representado	Notas
`\\`	`\`
`\'`	`'`
`\n`	Avance de línea (LF)
`\r`	Retorno de carro (CR)
`\t`	Carácter de tabulación
`\u{x}`	Punto de código Unicode `x`	x representa un valor de punto de código hexadecimal entre 0 y 10FFFF (ambos inclusive). Se permiten ceros a la izquierda. Los puntos de código por encima de FFFF se emiten como un par suplente.
`\$`	`$`	La secuencia de escape solo está permitida cuando va seguida de `{`.

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

Bicep admite el tipo literal de cadena que hace referencia a un valor de cadena específico. En el ejemplo siguiente, rojo es un tipo literal de cadena, redColor solo se puede asignar el valor rojo y ningún otro valor.

output redColor 'red' = 'red'

Un tipo literal de cadena se puede declarar en línea, como se muestra en el ejemplo anterior o en una type instrucción .

type redColor = 'red'

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

En el ejemplo anterior, la asignación de azul a colorBlue genera un error BCP033: se esperaba un valor de tipo "'rojo'", pero el valor proporcionado es de tipo "'blue'"..

En el ejemplo siguiente se muestra el uso del tipo literal de cadena con tipo de unión:

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

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

Todas las cadenas de Bicep admiten la interpolación. Para insertar una expresión, debe rodearla por ${ y }. Las expresiones a las que se hace referencia no pueden abarcar varias líneas.

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

Cadenas de varias líneas

En Bicep, las cadenas de varias líneas se definen entre tres caracteres de comilla simple (''') seguidos opcionalmente de una nueva línea (la secuencia de apertura) y tres caracteres de comilla simple (''': la secuencia de cierre). Los caracteres que se escriben entre las secuencias de apertura y cierre se leen textualmente y no es necesario ni posible el escape.

Nota

Dado que el analizador de Bicep lee todos los caracteres tal y como están, en función de los finales de línea del archivo Bicep, las nuevas líneas se pueden interpretar como \r\n o \n.

La interpolación no se admite actualmente en cadenas de varias líneas. Debido a esta limitación, es posible que tenga que usar la función concat en lugar de usar la interpolación.

No se admiten cadenas de varias líneas que contengan '''.

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

Tipos de unión

En Bicep, un tipo de unión permite la creación de un tipo combinado que consta de un conjunto de subtipos. Una asignación es válida si se permite alguna de las asignaciones de subtipo individuales. El | carácter separa los subtipos individuales mediante una condición o . Por ejemplo, la sintaxis 'a' | 'b' significa que una asignación válida podría ser 'a' o 'b'. Los tipos de unión se traducen en la restricción de valor permitido en Bicep, por lo que solo se permiten literales como miembros. Las uniones pueden incluir cualquier número de expresiones con tipo literal.

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)[]

Las uniones de tipos deben ser reducibles a un solo tipo ARM, como "string", "int" o "bool". De lo contrario, obtendrá el código de error BCP294 . Por ejemplo:

type foo = 'a' | 1

Cualquier expresión de tipo se puede usar como subtipo en una declaración de tipo de unión (entre | caracteres). Por ejemplo, los ejemplos siguientes son válidos:

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

Tipo de datos de unión etiquetado personalizado

Bicep admite el tipo de datos de unión etiquetado personalizado, que se usa para representar un valor que puede ser uno de varios tipos diferentes. Para declarar un tipo de datos de unión etiquetado personalizado, puede usar un @discriminator() decorador. Para usar este decorador se necesita la versión 0.21.X o posterior de la CLI de Bicep. La sintaxis es:

@discriminator('<property-name>')

El decorador discriminador toma un único parámetro, que representa un nombre de propiedad compartida entre todos los miembros de la unión. Este nombre de propiedad debe ser un literal de cadena obligatorio en todos los miembros y distingue mayúsculas de minúsculas. Los valores de la propiedad discriminada en los miembros de la unión deben ser únicos de una manera sin distinción entre mayúsculas y minúsculas.

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 }

El valor del parámetro se valida en función del valor de la propiedad discriminada. Por ejemplo, en el ejemplo anterior, si el parámetro serviceConfig es de tipo foo, se valida mediante el tipo FooConfig . Del mismo modo, si el parámetro es de barra de tipos, se valida mediante el tipo BarConfig. Este patrón también se aplica a otros tipos.

Existen algunas limitaciones con el tipo de unión.

Los tipos de unión deben ser reducibles a un único tipo de Azure Resource Manager (ARM). La siguiente definición no es válida:
```
type foo = 'a' | 1
```
Solo se permiten literales como miembros.
Todos los literales deben ser del mismo tipo de datos primitivo (por ejemplo, todas las cadenas o todos los enteros).

La sintaxis de tipo de unión se puede usar en tipos de datos definidos por el usuario.

Protección de cadenas y objetos

La cadena segura usa el mismo formato que la cadena y el objeto seguro usa el mismo formato que el objeto. Con Bicep, se agrega el @secure() decorador a una cadena o objeto.

Cuando se establece un parámetro en una cadena segura o un objeto seguro, el valor del parámetro no se guarda en el historial de implementaciones y no se registra. Sin embargo, si establece ese valor seguro en una propiedad que no espera un valor seguro, el valor no está protegido. Por ejemplo, si establece una cadena segura en una etiqueta, ese valor se almacena como texto sin formato. Use cadenas seguras para contraseñas y secretos.

En el ejemplo siguiente se muestran dos parámetros seguros:

@secure()
param password string

@secure()
param configValues object

Capacidad de asignación de tipos de datos

En Bicep, se puede asignar un valor de un tipo (tipo de origen) a otro tipo (tipo de destino). En la tabla siguiente se muestra qué tipo de origen (enumerado horizontalmente) se puede asignar o no a qué tipo de destino (enumerado verticalmente). En la tabla, X significa asignable, un espacio vacío significa que no se puede asignar y ? indica solo si sus tipos son compatibles.

Tipos	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	recurso con nombre	módulo con nombre	`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`											?
recurso con nombre	X						?		?
módulo con nombre	X						?			?

Pasos siguientes

Para información sobre la estructura y la sintaxis de Bicep, vea Estructura de archivos de Bicep.

Compartir por