Partilhar via

Tipos de dados no Bicep

  • Artigo

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

Matrizes

As matrizes começam com um colchete esquerdo ([) e terminam com um colchete direito (]). No Bicep, você pode declarar uma matriz 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']

Cada elemento de matriz pode ser de 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 índice do indexador pode ser outra expressão. A expressão exampleArray[index] é avaliada como 2. 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, use 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
  • Use operadores de comparação para comparar duas matrizes.
  • Use o acessador de índice para obter um elemento de uma matriz.
  • Use o operador Safe-dereference para acessar elementos de uma matriz.
  • Use Spread para mesclar matrizes.

Booleanos

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

param exampleBool bool = true

Consulte Função lógica

Números inteiros

Ao especificar valores inteiros, não use aspas.

param exampleInt int = 1

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

O bíceps suporta um tipo literal inteiro que se refere a um valor específico que é um inteiro exato. No exemplo a seguir, 1 é um tipo literal inteiro e foo só pode ser atribuído o valor 1 e nenhum outro valor.

output foo 1 = 1

Você pode declarar um tipo literal inteiro inline, como 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 a bar resulta em um erro BCP033: "Esperado um valor do tipo1, 2 mas o valor fornecido é do tipo2."

O exemplo a seguir usa um tipo literal inteiro com um tipo de união:

output bar 1 | 2 | 3 = 3

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

Consulte Funções numéricas.

Objetos

Os objetos começam com uma chave esquerda ({) e terminam com uma chave direita (}). No Bicep, você pode declarar um objeto em uma única linha ou em várias linhas. Cada propriedade em um objeto consiste em uma chave e um 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 opcionalmente permitidas 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. Exemplos são 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

Você pode usar acessadores de propriedade com qualquer objeto, incluindo parâmetros e variáveis de tipos de objeto e literais de objeto. Um acessador de propriedade usado em uma expressão de um tipo que 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 de chaves ou valores. A ordenação pode ser diferente dependendo das implementações. Por exemplo, a função Bicep items() classifica os objetos em ordem alfabética. Em outros lugares, você pode preservar o pedido original. 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 e saídas de implantação.

Você obtém o seguinte erro quando você acessa 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
  • Use operadores de comparação para comparar objetos.
  • Use o acessador de índice para obter uma propriedade de um objeto.
  • Use o operador Safe-dereference para acessar os membros do objeto.
  • Use Spread para mesclar objetos.

Consulte Funções do objeto.

Cadeias

No Bicep, as cadeias de caracteres são marcadas com aspas simples e você deve declará-las 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 você deve escapar usando 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 O 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 FFFF são emitidos como um par substituto.
\$ $ Só escape quando seguido por {. 
// evaluates to "what's up?"
var myVar = 'what\'s up?'

O Bicep suporta um 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. Você só pode atribuir o valor red a redColor.

output redColor 'red' = 'red'

Você pode declarar um tipo literal de cadeia de caracteres embutido, como 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 a colorBlue resulta em um erro BCP033: "Esperado um valor do tipored, blue mas o valor fornecido é do tipoblue."

O exemplo a seguir mostra um tipo literal de cadeia de caracteres usado com um 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 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 aspas simples (''') seguidas opcionalmente por uma nova linha (a sequência de abertura) e três aspas simples (''' é a sequência de fechamento). Os caracteres inseridos entre a sequência de abertura e fechamento são lidos textualmente. Escapar não é necessário ou possível.

Nota

O analisador Bicep lê todos os caracteres como estão. Dependendo das terminações de linha do seu arquivo Bicep, as novas linhas são interpretadas como ou \r\n \n.

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

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

// 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 da 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 que usam uma or condição. Por exemplo, a sintaxe a | b significa que uma atribuição válida pode ser ou a b. Os tipos de união são traduzidos na restrição de valor permitido no Bicep, portanto, apenas literais são permitidos como membros. As uniões podem incluir qualquer número de expressões digitadas literalmente.

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 do Azure Resource Manager, como string, intou bool. Caso contrário, obterá o código de erro BCP294 . Por exemplo:

type foo = 'a' | 1

Você pode usar qualquer expressão de tipo como um subtipo em uma declaração de tipo de união (entre | caracteres). Por exemplo, os seguintes exemplos 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 tags personalizadas

O Bicep suporta um tipo de dados de união com tags personalizadas, que é usado para representar um valor que pode ser um dos vários tipos. Para declarar um tipo de dados de união com etiquetas personalizadas, você pode usar um @discriminator() decorador. Bicep CLI versão 0.21.X ou superior é necessário para usar este decorador. A sintaxe é:

@discriminator('<property-name>')

O decorador discriminador usa um único parâmetro, que representa um nome de propriedade compartilhada entre todos os membros do sindicato. Esse nome de propriedade deve ser uma cadeia de caracteres literal necessária em todos os membros e diferencia maiúsculas de minúsculas. Os valores dos bens discriminados sobre os membros do sindicato 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 serviceConfig parâmetro for do tipo foo, ele é validado usando o FooConfig tipo. Da mesma forma, se o parâmetro for do tipo bar, ele é validado usando o BarConfig tipo. Este padrão também se aplica a outros tipos.

O tipo de união tem algumas limitações:

  • Os tipos de união devem ser redutíveis a um único tipo do Azure Resource Manager. A seguinte definição é inválida:

    type foo = 'a' | 1

  • Apenas literais são permitidos como membros.

  • Todos os literais devem ser do mesmo tipo de dados primitivo (por exemplo, todas as cadeias de caracteres ou todos os inteiros).

Você pode usar a sintaxe de tipo união em tipos de dados definidos pelo usuário.

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. 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, você pode atribuir um valor de um tipo (tipo de origem) a outro tipo (tipo de destino). A tabela a seguir mostra qual tipo de origem (listado horizontalmente) você pode ou não atribuir a qual tipo de destino (listado verticalmente). Na tabela, X significa atribuível, um espaço vazio significa não atribuível e ? significa apenas se os tipos forem compatíveis.

Tipos any error 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 ? ?

Conteúdos relacionados

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