Tipos de datos de Bicep

  • Artículo

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:

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']

En una matriz, cada elemento se representa mediante 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

En Bicep, los enteros son enteros de 64 bits. Al pasarlos como parámetros en línea, el intervalo de valores puede estar limitado por el SDK o la herramienta de línea de comandos que use 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.

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.

Obtendrá el siguiente error al acceder 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?'

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

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 a un 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 error 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.