Tipos de dados no Bicep

Artigo
11/08/2023

Este artigo descreve os tipos de dados suportados no Bicep. Para definir tipos de dados personalizados, consulte Tipos de dados definidos pelo usuário.

Tipos suportados

Dentro de um Bicep, você pode usar estes tipos de dados:

matriz
Bool
Int
objeto
secureObject - indicado pelo decorador no Bicep
secureString - indicado pelo decorador em Bicep
string

Matrizes

As matrizes começam com um colchete esquerdo () e terminam com um colchete direito ([]). No Bicep, uma matriz pode ser declarada em uma única linha ou em várias linhas. As vírgulas (,) são usadas entre valores em declarações de linha única, mas não são usadas em declarações de várias linhas, Você pode misturar e combinar declarações de linha única e de várias linhas. A declaração de várias linhas requer a CLI do Bicep versão 0.7.X ou superior.

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

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

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

Em uma matriz, cada item é representado por qualquer tipo. Você pode ter uma matriz onde cada item é o mesmo tipo de dados ou uma matriz que contém tipos de dados diferentes.

O exemplo a seguir mostra uma matriz de inteiros e uma matriz de tipos diferentes.

var integerArray = [
  1
  2
  3
]

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

As matrizes no Bicep são baseadas em zero. No exemplo a seguir, a expressão exampleArray[0] avalia como 1 e exampleArray[2] avalia como 3. O próprio índice do indexador pode ser outra expressão. A expressão exampleArray[index] é avaliada como 2. Os indexadores inteiros só são permitidos na expressão de tipos de matriz.

var index = 1

var exampleArray = [
  1
  2
  3
]

Você recebe o seguinte erro quando o índice está fora dos limites:

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

Para evitar essa exceção, você pode usar o operador lógico Or como mostrado no exemplo a seguir:

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

Booleanos

Ao especificar valores booleanos, use true ou false. Não envolva o valor com aspas.

param exampleBool bool = true

Números inteiros

Ao especificar valores inteiros, não use aspas.

param exampleInt int = 1

No Bicep, inteiros são inteiros de 64 bits. Quando passados como parâmetros embutidos, o intervalo de valores pode ser limitado pelo SDK ou pela ferramenta de linha de comando que você usa para implantação. Por exemplo, ao usar o PowerShell para implantar um Bicep, os tipos inteiros podem variar de -2147483648 a 2147483647. Para evitar essa limitação, especifique valores inteiros grandes em um arquivo de parâmetro. Os tipos de recursos aplicam seus próprios limites para propriedades inteiras.

Atualmente, não há suporte para formatos de ponto flutuante, decimal ou binário.

Objetos

Os objetos começam com uma chave esquerda () e terminam com uma chave direita ({}). No Bicep, um objeto pode ser declarado em uma única linha ou em várias linhas. Cada propriedade em um objeto consiste em chave e valor. A chave e o valor são separados por dois pontos (:). Um objeto permite qualquer propriedade de qualquer tipo. As vírgulas (,) são usadas entre propriedades para declarações de linha única, mas não são usadas entre propriedades para declarações de várias linhas. Você pode misturar e combinar declarações de linha única e de várias linhas. A declaração de várias linhas requer a CLI do Bicep versão 0.7.X ou superior.

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}

No Bicep, as aspas são permitidas opcionalmente em chaves de propriedade de objeto:

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

No exemplo anterior, as aspas são usadas quando as chaves de propriedade do objeto contêm caracteres especiais. Por exemplo, espaço, '-', ou '.'. O exemplo a seguir mostra como usar a interpolação em chaves de propriedade de objeto.

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

Os acessadores de propriedade são usados para acessar propriedades de um objeto. Eles são construídos usando o . 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

Os acessadores de propriedade podem ser usados com qualquer objeto, incluindo parâmetros e variáveis de tipos de objeto e literais de objeto. Usar um acessador de propriedade em uma expressão do tipo não-objeto é um erro.

Você também pode usar a [] sintaxe para acessar uma propriedade. O exemplo a seguir retorna Development.

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

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

Em JSON, um objeto é uma coleção não ordenada de zero ou mais pares chave/valor. A ordenação pode ser diferente dependendo das implementações. Por exemplo, a função Bicep items() classifica os objetos na ordem alfabética. Em outros lugares, o pedido original pode ser preservado. Devido a esse não-determinismo, evite fazer suposições sobre a ordenação de chaves de objeto ao escrever código, que interage com parâmetros de implantação e saídas.

Você receberá o seguinte erro ao acessar uma propriedade inexistente de um objeto:

The language expression property 'foo' doesn't exist

Para evitar a exceção, você pode usar o operador lógico And como mostrado no exemplo a seguir:

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

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

Cadeias

No Bicep, as cadeias de caracteres são marcadas com aspas simples e devem ser declaradas em uma única linha. Todos os caracteres Unicode com pontos de código entre 0 e 10FFFF são permitidos.

param exampleString string = 'test value'

A tabela a seguir lista o conjunto de caracteres reservados que devem ser escapados por um caractere de barra invertida (\):

Sequência de fuga	Valor representado	Notas
`\\`	`\`
`\'`	`'`
`\n`	alimentação de linha (LF)
`\r`	retorno de carro (CR)
`\t`	caractere de tabulação
`\u{x}`	Ponto de código Unicode `x`	x representa um valor de ponto de código hexadecimal entre 0 e 10FFFF (ambos inclusive). São permitidos zeros à esquerda. Os pontos de código acima de FFFF são emitidos como um par substituto.
`\$`	`$`	Só escape quando seguido por `{`.

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

Todas as cadeias de caracteres no Bicep suportam interpolação. Para injetar uma expressão, rodeie-a por ${ e }. As expressões referenciadas não podem abranger várias linhas.

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

Strings de várias linhas

No Bicep, as cadeias de caracteres de várias linhas são definidas entre três caracteres de aspas simples () seguidas opcionalmente por uma nova linha (a sequência de abertura) e três caracteres de aspas simples ('''''' - a sequência de fechamento). Os caracteres inseridos entre a sequência de abertura e de encerramento são lidos literalmente, e nenhuma fuga é necessária ou possível.

Nota

Como o analisador Bicep lê todos os caracteres como estão, dependendo das terminações de linha do arquivo Bicep, as novas linhas podem ser interpretadas como um \r\n ou \n.

Atualmente, não há suporte para interpolação em cadeias de caracteres de várias linhas. Devido a esta limitação, você pode precisar usar a concat função em vez de usar interpolação.

Não há suporte para cadeias de caracteres de várias linhas que contenham ''' caracteres.

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

Proteja cadeias de caracteres e objetos

Secure string usa o mesmo formato que string, e secure object usa o mesmo formato que object. Com o Bicep, você adiciona o @secure()decorador a uma string ou objeto.

Quando você define um parâmetro para uma cadeia de caracteres ou objeto seguro, o valor do parâmetro não é salvo no histórico de implantação e não é registrado. No entanto, se você definir esse valor seguro para uma propriedade que não está esperando um valor seguro, o valor não será protegido. Por exemplo, se você definir uma cadeia de caracteres segura para uma tag, esse valor será armazenado como texto sem formatação. Use cadeias de caracteres seguras para senhas e segredos.

O exemplo a seguir mostra dois parâmetros seguros:

@secure()
param password string

@secure()
param configValues object

Atribuição de tipo de dados

No Bicep, um valor de um tipo (tipo de origem) pode ser atribuído a outro tipo (tipo de destino). A tabela a seguir mostra qual tipo de origem (listado horizontalmente) pode ou não ser atribuído a qual tipo de destino (listado verticalmente). Na tabela, significa atribuível, espaço vazio significa não atribuível, X e ? significa apenas se os tipos forem compatíveis.

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

Próximos passos

Para saber mais sobre a estrutura e a sintaxe do Bicep, consulte Estrutura do arquivo Bicep.