Compartir vía

Tipos de datos de Bicep

  • Artículo

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

Matrices

Las matrices comienzan con un corchete de apertura ([) y terminan con un corchete de cierre (]). En Bicep, puede declarar una matriz en una sola línea o en varias líneas. 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 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.

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

var integerArray = [
  1
  2
  3
]

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

Las matrices de Bicep se basan en 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 podría ser otra expresión. La expresión exampleArray[index] se evalúa en 2. Los indizadores 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, use 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

Consulte Función lógica.

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 SDK o la herramienta de línea de comandos que se usa para la implementación pueden limitar el intervalo de valores. Por ejemplo, cuando se usa PowerShell para implementar Bicep, los tipos 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 un 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 y foo solo se puede asignar el valor 1 y ningún otro valor.

output foo 1 = 1

Puede declarar un tipo literal entero insertado, 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 2 a bar da como resultado un error BCP033 : "Se esperaba un valor de tipo 1 , pero el valor proporcionado es de tipo 2".

En el ejemplo siguiente se usa un tipo literal entero con un tipo de unión:

output bar 1 | 2 | 3 = 3

Actualmente no se admiten formatos de punto flotante, decimales o binarios.

Consulte Funciones numéricas.

Objetos

Los objetos comienzan con una llave de apertura ({) y terminan con una llave de cierre (}). En Bicep, puede declarar un objeto en una sola línea o 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. 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. Algunos ejemplos son el 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

Puede usar descriptores de acceso de propiedad con cualquier objeto, incluidos parámetros y variables de tipos de objeto y literales de objeto. Un descriptor de acceso de propiedad usado en una expresión de un tipo no de 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 o valor. La ordenación puede ser diferente en función de las implementaciones. Por ejemplo, la función Bicep items() ordena los objetos en orden alfabético. En otros lugares, 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 de implementación y las salidas.

Aparece 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

Consulte Funciones de objeto.

Cadenas

En Bicep, las cadenas se marcan con comillas simples y debe declararlas 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 debe escapar mediante un carácter de 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 anteriores 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 un tipo literal de cadena que hace referencia a un valor de cadena específico. En el ejemplo siguiente, red es un tipo literal de cadena. Solo puede asignar el valor red a redColor.

output redColor 'red' = 'red'

Puede declarar un tipo literal de cadena 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 blue a colorBlue da como resultado un error BCP033 : "Se esperaba un valor de tipo red , pero el valor proporcionado es de tipo blue".

En el ejemplo siguiente se muestra un tipo literal de cadena usado con un 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 comillas simples (''') seguidas opcionalmente por una nueva línea (la secuencia de apertura) y tres comillas simples (''' es la secuencia de cierre). Los caracteres que se escriben entre la secuencia de apertura y cierre se leen textualmente. El escape no es necesario o posible.

Nota:

El analizador de Bicep lee todos los caracteres tal como está. En función de los finales de línea del archivo de Bicep, las líneas nuevas se interpretan 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 en lugar de usar la concat interpolación.

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

// 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 que usan una or condición. 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 único tipo de Azure Resource Manager, como string, into bool. De lo contrario, obtendrá el código de error BCP294 . Por ejemplo:

type foo = 'a' | 1

Puede usar cualquier expresión de tipo 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 un tipo de datos de unión etiquetado personalizado, que se usa para representar un valor que puede ser uno de varios tipos. 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 serviceConfig parámetro es de tipo foo, se valida mediante el FooConfig tipo . Del mismo modo, si el parámetro es de tipo bar, se valida mediante el BarConfig tipo . Este patrón también se aplica a otros tipos.

El tipo de unión tiene algunas limitaciones:

  • Los tipos de unión deben ser reducibles a un único tipo de Azure Resource Manager. 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).

Puede usar la sintaxis de tipo de unión en los 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. 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, puede asignar un valor de un tipo (tipo de origen) a otro (tipo de destino). En la tabla siguiente se muestra el tipo de origen (enumerado horizontalmente) que puede o no se puede asignar al tipo de destino (enumerado verticalmente). En la tabla, X significa asignable, un espacio vacío significa no asignable y ? significa solo si los 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 ? ?

Contenido relacionado

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