Tipos de datos de Bicep

En este artículo se describen los tipos de datos admitidos en Bicep.

Tipos admitidos

Dentro de Bicep, puede usar estos tipos de datos:

• array
• bool
• int
• object
• secureObject: indicado por el modificador de Bicep.
• secureString: indicado por el modificador de Bicep.
• string

Matrices

Las matrices comienzan con un corchete de apertura ([) y terminan con un corchete de cierre (]). En Bicep, una matriz se debe declarar en varias líneas. No use comas entre valores.

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
]

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 debe declarar en varias líneas. 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. No use comas entre las propiedades.

param exampleObject 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

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 (\):

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

// 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
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, el modificador @secure() se agrega a una cadena u 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.

Pasos siguientes

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