Tipos de dados em Bicep

Artigo
07/23/2024

Este artigo descreve os tipos de dados compatíveis com o Bicep. Para definir os tipos de dados personalizados, consulte Tipos de dados definidos pelo usuário.

Tipos com suporte

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

array
bool
int
object
secureObject – indicado por decorador em Bicep
secureString – indicado por decorador em Bicep
cadeia de caracteres

Matrizes

As matrizes começam com um colchete esquerdo ( [) e terminam com um colchete direito (]). No Bicep, uma matriz pode ser declarada em uma só linha ou em várias linhas. Vírgulas (,) são usadas entre valores em declarações de linha única, mas não em declarações de várias linhas. Você pode misturar e corresponder 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']

Cada elemento de matriz pode ser de qualquer tipo. Você pode ter uma matriz cujos itens são do 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 em Bicep são baseadas em zero. No exemplo a seguir, a expressão exampleArray[0] é avaliada como 1 e exampleArray[2] é avaliada como 3. O índice do indexador pode ser outra expressão. A expressão exampleArray[index] é avaliada como 2. Indexadores de inteiros são permitidos somente em expressões 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, conforme 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

Boolianos

Ao especificar valores boolianos, use true ou false. Não coloque o valor entre aspas.

param exampleBool bool = true

Inteiros

Ao especificar valores inteiros, não use aspas.

param exampleInt int = 1

Os inteiros do Bicep são inteiros de 64 bits. Quando passado 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 de números 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 recurso aplicam seus próprios limites para propriedades de números inteiros.

O Bicep dá suporte ao tipo literal inteiro que se refere a um valor específico que é um inteiro exato. No exemplo a seguir, 1 é um tipo literal inteiro, foo só pode ser atribuído ao valor 1 e nenhum outro valor.

output foo 1 = 1

Um tipo literal inteiro pode ser declarado embutido, conforme mostrado no exemplo anterior, ou em uma type instrução.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

No exemplo anterior, atribuir 2 à barra resulta em um erro BCP033 - Esperado um valor do tipo "1", mas o valor fornecido é do tipo "2".

O exemplo a seguir mostra o uso do tipo literal inteiro com o tipo de união:

output bar 1 | 2 | 3 = 3

Os formatos de ponto flutuante, decimal ou binário não são compatíveis no momento.

Objetos

Os objetos começam com uma chave esquerda ({) e terminam com uma chave direita (}). No Bicep, um objeto pode ser declarado em linha única 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. Vírgulas (,) são usadas entre propriedades para declarações de linha única, mas não usadas entre propriedades para declarações de várias linhas. Você pode misturar e corresponder 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, aspas são permitidas como opção 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 de objeto contêm caracteres especiais. Por exemplo, espaço, '-' ou '.'. O exemplo a seguir mostra como usar a interpolação nas chaves de propriedade de objeto.

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

Os acessadores de propriedade são usados para acessar as 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 de tipo não objeto é um erro.

Use também 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

No 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 items() do Bicep classifica os objetos na ordem alfabética. Em outros locais, a ordenação original pode ser preservada. Devido a esse não determinismo, evite fazer suposições sobre a ordem das chaves de objeto ao escrever códigos que interagem com parâmetros e saídas de implantações.

Você recebe 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, conforme mostrado no exemplo a seguir:

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

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

Cadeias de caracteres

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

param exampleString string = 'test value'

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

Sequência de escape	Valor representado	Observações
`\\`	`\`
`\'`	`'`
`\n`	LF (alimentação de linha)
`\r`	CR (retorno de carro)
`\t`	caractere de tabulação
`\u{x}`	Ponto de código Unicode `x`	x representa um valor ponto hexadecimal entre 0 e 10FFFF (ambos incluídos). São permitidos zeros à esquerda. Pontos de código acima de FFFF são emitidos como um par alternativo.
`\$`	`$`	Escape somente quando seguido por `{`.

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

O Bicep dá suporte ao tipo literal de cadeia de caracteres que se refere a um valor de cadeia de caracteres específico. No exemplo a seguir, red é um tipo literal de cadeia de caracteres, redColor só pode receber o valor red e nenhum outro valor.

output redColor 'red' = 'red'

Um tipo literal de cadeia de caracteres pode ser declarado embutido, conforme mostrado no exemplo anterior, ou em uma type instrução.

type redColor = 'red'

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

No exemplo anterior, atribuir azul a colorBlue resulta em um erro BCP033 - Esperava-se um valor do tipo "'red'", mas o valor fornecido é do tipo "'blue'".

O exemplo a seguir mostra o uso do tipo literal de cadeia de caracteres com o tipo de união:

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

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

Todas as cadeias de caracteres no Bicep dão suporte à interpolação. Para injetar uma expressão, coloque-a entre ${ e }. As expressões que são referenciadas não podem abranger várias linhas.

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

Cadeias de caracteres de várias linhas

No Bicep, as cadeias de caracteres de várias linhas são definidas entre três caracteres de aspas simples (''') seguidos opcionalmente por uma nova linha (a sequência de abertura) e três caracteres de aspas simples (''' – a sequência de fechamento). Os caracteres que são inseridos entre a sequência de abertura e fechamento são lidos de modo textual e nenhuma saída é necessária nem possível.

Observação

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 \r\n ou \n.

Atualmente, não há suporte para a interpolação em cadeias de caracteres de várias linhas. Devido a essa limitação, talvez seja necessário usar a função concat em vez de usar a interpolação.

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

// 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ão

No Bicep, um tipo de união permite a criação de um tipo combinado que consiste em um conjunto de subtipos. Uma atribuição é válida se qualquer uma das atribuições de subtipo individuais for permitida. O | caractere separa subtipos individuais usando uma condição or . Por exemplo, a sintaxe 'a' | 'b' significa que uma atribuição válida pode ser 'a' ou 'b'. Os tipos de união são convertidos na restrição de valor permitido no Bicep, portanto, somente literais são permitidos como membros. As uniões podem incluir qualquer número de expressões de 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)[]

As uniões de tipo devem ser redutíveis a um único tipo ARM, como 'string', 'int' ou 'bool'. Caso contrário, você receberá o código de erro BCP294 . Por exemplo:

type foo = 'a' | 1

Qualquer expressão de tipo pode ser usada como um subtipo em uma declaração de tipo de união (entre | caracteres). Por exemplo, os exemplos a seguir são todos válidos:

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

Tipo de dados de união com marca personalizada

O Bicep dá suporte ao tipo de dados de união marcada personalizada, que é usado para representar um valor que pode ser um dos vários tipos diferentes. Para declarar um tipo de dados de união com marca personalizada, você pode usar um @discriminator() decorador. A CLI do Bicep versão 0.21.X ou superior é necessária para usar esse decorador. A sintaxe do é:

@discriminator('<property-name>')

O decorador discriminador usa um único parâmetro, que representa um nome de propriedade compartilhado entre todos os membros da união. Esse nome de propriedade deve ser um literal de cadeia de caracteres obrigatório em todos os membros e diferencia maiúsculas de minúsculas. Os valores dos bens discriminados sobre os membros da união devem ser únicos de forma insensível a maiúsculas e 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 }

O valor do parâmetro é validado com base no valor da propriedade discriminada. Por exemplo, no exemplo anterior, se o parâmetro serviceConfig for do tipo foo, ele será validado usando o tipo FooConfig . Da mesma forma, se o parâmetro for do tipo bar, ele será validado usando o tipo BarConfig. Esse padrão também se aplica a outros tipos.

Existem algumas limitações com o tipo de união.

Os tipos de união devem ser redutíveis a um único tipo do ARM (Azure Resource Manager). A seguinte definição é inválida:
```
type foo = 'a' | 1
```
Somente literais são permitidos como membros.
Todos os literais devem ser do mesmo tipo de dados primitivos (por exemplo, todas as cadeias de caracteres ou todos os inteiros).

A sintaxe do tipo de união pode ser usada em tipos de dados definidos pelo usuário.

Cadeias de caracteres e objetos seguros

A cadeia de caracteres segura usa o mesmo formato que uma cadeia de caracteres e o objeto seguro usa o mesmo formato que um objeto. Com o Bicep, você adiciona o @secure() decorador a uma string ou objeto.

Quando você define um parâmetro como cadeia de caracteres segura ou objeto seguro, o valor do parâmetro não é salvo no histórico de implantação e não é registrado em log. No entanto, se você definir esse valor seguro como 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 como marca, 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

Capacidade de 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, X significa atribuível, espaço vazio significa não atribuível e ? significa apenas se os tipos são 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óximas etapas

Para saber mais sobre a estrutura e a sintaxe do Bicep, confira estrutura de arquivos do Bicep.

Compartilhar via