Tipos de dados em Bicep

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

Qualquer

Com a versão Bicep v0.38.3 e posterior, o any tipo no Bicep é um tipo permissivo que desabilita a verificação de tipo de tempo de compilação para o símbolo associado. Um valor de tipo any pode conter dados de qualquer tipo, incluindo expressões complexas, incluindo string, int, bool, arrayou object.

param foo any
output bar any = foo

No exemplo anterior, foo pode aceitar qualquer tipo de valor e bar gera o mesmo valor foo que independentemente de seu tipo.

Como any ignora a segurança de tipo do Bicep, ela só deve ser usada quando o tipo exato não pode ser determinado com antecedência. Por exemplo, ao passar dados por meio de um módulo que manipula várias formas de dados ou ao trabalhar com entrada JSON não tipada.

O uso any torna o Bicep menos previsível e pode levar a erros de runtime. Quando possível, prefira tipos específicos ou uma união de tipos esperados para preservar a validação e o suporte do IntelliSense. A regra No explicit Any linter ajuda a identificar e desencorajar o uso do any tipo em arquivos Bicep.

matrizes

Uma matriz no Bicep é uma coleção ordenada de valores, como cadeias de caracteres, inteiros, objetos ou até mesmo outras matrizes, geralmente usada para agrupar itens relacionados, como nomes de recursos, configurações ou parâmetros. As matrizes são úteis para organizar dados de implantação, passar listas para recursos e iterar em vários valores.

Matrizes no Bicep são imutáveis. Depois de declarado, seu conteúdo não pode ser alterado. Para "modificar" uma matriz, crie uma nova matriz usando funções como concat, mapou filter.

param usLocations array = [
  'eastus'
  'westus2'
]

param euroLocations string[] = [
  'northeurope'
  'westeurope'
]

param numbers int[] = [
  1
  2
  3
]

Você pode declarar matrizes no Bicep usando sintaxe de linha única ou de várias linhas. Declarações de matriz de várias linhas exigem a CLI do Bicep versão 0.7.X ou posterior.

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

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

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

Matrizes de linha única usam vírgulas (,) para separar valores. Matrizes de várias linhas não usam vírgulas entre valores. Você pode misturar declarações de linha única e de várias linhas conforme necessário.

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.

var integerArray = [
  1
  2
  3
]

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

var arrayOfObjects = [
  { name: 'dev', size: 1 }
  { name: 'prod', size: 2 }
]

As matrizes em Bicep são baseadas em zero. Você pode acessar elementos por índice:

var exampleArray = [1, 2, 3]
output firstElement int = exampleArray[0] // 1
output thirdElement int = exampleArray[2] // 3

var index = 1
output secondElement int = exampleArray[index] // 2

Começando com a CLI do Bicep versão 0.34.x, você pode usar a array[^index] sintaxe para acessar elementos do final de uma matriz – ^1 refere-se ao último elemento, ^2 ao penúltimo e assim por diante.

var exampleArray = [1, 2, 3]

output lastElement int = exampleArray[^1] // 3
output secondToLastElement int = exampleArray[^2] // 2

Se você acessar um índice fora dos limites, receberá um erro:

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

Para evitar exceção fora dos limites, 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

Operadores relacionados a arrays

• Use operadores de comparação para comparar duas matrizes.
• Use o acessador Index para obter um elemento de uma matriz.
• Use o operador Safe-dereference para acessar elementos de uma matriz.
• Use Spread para mesclar matrizes.

Funções relacionadas a arrays

• Consulte Funções de matriz.
• Consulte Funções do Lambda.

Boolianos

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

param exampleBool bool = true

Operadores relacionados ao booleano

• Use operadores de comparação para comparar valores booleanos.
• Consulte Operadores lógicos.

Funções relacionadas ao booleano

Consulte Função lógica

Inteiros

Ao especificar valores inteiros, não use aspas.

param exampleInt int = 1

Os inteiros do Bicep 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 recurso aplicam seus próprios limites para propriedades de números inteiros.

O Bicep dá suporte a 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 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, a atribuição 2 a resulta em um bar: "Esperava-se um valor do tipo, mas o valor fornecido é do tipo 12 ."

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

output bar 1 | 2 | 3 = 3

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

Operadores relacionados a inteiros

• Consulte Operadores de comparação.
• Consulte Operadores numéricos.

Funções relacionadas a inteiros

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

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

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 seja 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

Em JSON, um objeto é uma coleção não ordenada de zero ou mais pares de chave ou valor. 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 a ordem 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 de implantação e saídas.

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

Operadores relacionados a objetos

• Use operadores de comparação para comparar objetos.
• Use o acessador Index para obter uma propriedade de um objeto.
• Use o operador Safe-dereference para acessar membros do objeto.
• Use Spread para mesclar objetos.

Funções relacionadas a objetos

Consulte Funções de objeto.

Cadeias de caracteres

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

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

O Bicep dá suporte a 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, 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, a atribuição blue a resulta em um colorBlue: "Esperava-se um valor do tipo, mas o valor fornecido é do tipo redblue ."

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 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 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 literalmente. Escapar não é necessário ou possível.

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

Operadores relacionados à cadeia de caracteres

• Consulte Operadores de comparação.

Funções relacionadas à cadeia de caracteres

• Consulte funções de cadeia de caracteres.

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 individual 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 ab. 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 do 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 do Azure Resource Manager, como string, int, ou bool. Caso contrário, você receberá o código de erro BCP294 . Por exemplo:

type foo = 'a' | 1

Você pode usar qualquer tipo de expressão 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 a um tipo de dados de união com marca personalizada, que representa um valor que pode ser um dos vários tipos. 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 posterior é 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 necessá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 serviceConfig parâmetro for do tipo foo, ele será validado usando o FooConfig tipo. Da mesma forma, se o parâmetro for do tipo bar, ele será validado usando o BarConfig tipo. Esse 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
  

• 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).

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

Tipos anuláveis

Você pode tornar qualquer tipo primitivo ou complexo anulável acrescentando um ? ao nome do tipo. Isso permite que o parâmetro, a variável ou a saída aceite nulos como um valor válido. Por exemplo:

output description string? = null
output config object? = null
output optionalValue int? = null

Cadeias de caracteres e objetos seguros

As cadeias de caracteres seguras usam o mesmo formato que a cadeia de caracteres e os objetos seguros usam o mesmo formato que o objeto. Com o Bicep, você adiciona o @secure()decorador a uma string ou objeto.

Quando você define um parâmetro (ou uma saída) para uma cadeia de caracteres segura ou objeto seguro, o valor do parâmetro (ou a saída) não é salvo no histórico de implantação ou registrado (exceto se o parâmetro --debug for usado). 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

Para obter mais informações, consulte Parâmetros seguros e saídas seguras.

Capacidade de 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.

Próximas etapas

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