Datové typy v Bicep

Článek
11/08/2023

Tento článek popisuje datové typy podporované v Bicep. Pokud chcete definovat vlastní datové typy, přečtěte si téma Uživatelsky definované datové typy.

Podporované typy

V rámci bicep můžete použít tyto datové typy:

Pole
bool
int
object
secureObject – označený dekorátorem v Bicep
secureString – označený dekorátorem v Bicep
string

Pole

Pole začínají levou závorkou ([) a končí pravou závorkou (]). V bicep lze pole deklarovat v jednom řádku nebo více řádcích. Čárky (,) se používají mezi hodnotami v jednořádkových deklaracích, ale nepoužívají se v víceřádkových deklaracích, můžete kombinovat a odpovídat jednořádkovým a víceřádkovým deklaracím. Deklarace víceřádkového řádku vyžaduje rozhraní příkazového řádku Bicep verze 0.7.X nebo vyšší.

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

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

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

V poli je každá položka reprezentována libovolným typem. Můžete mít pole, kde každá položka je stejného datového typu, nebo pole, které obsahuje různé datové typy.

Následující příklad ukazuje pole celých čísel a různých typů pole.

var integerArray = [
  1
  2
  3
]

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

Pole v Bicep jsou založená na nule. V následujícím příkladu se výraz exampleArray[0] vyhodnotí jako 1 a exampleArray[2] vyhodnotí se jako 3. Index indexeru může být jiný výraz. Výraz exampleArray[index] se vyhodnotí jako 2. Celočíselné indexery jsou povoleny pouze pro výraz typů polí.

var index = 1

var exampleArray = [
  1
  2
  3
]

Pokud je index mimo hranice, zobrazí se následující chyba:

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

Pokud se chcete této výjimce vyhnout, můžete použít logický operátor Or, jak je znázorněno v následujícím příkladu:

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

Logické hodnoty

Při zadávání logických hodnot použijte true nebo false. Neohranižujte hodnotu uvozovkami.

param exampleBool bool = true

Celá čísla

Při zadávání celočíselné hodnoty nepoužívejte uvozovky.

param exampleInt int = 1

V bicep jsou celá čísla 64bitová celá čísla. Při předání jako vložené parametry může být rozsah hodnot omezen sadou SDK nebo nástrojem příkazového řádku, který používáte k nasazení. Pokud například k nasazení Bicep používáte PowerShell, můžou být celočíselné typy v rozsahu od -2147483648 po 2147483647. Chcete-li se tomuto omezení vyhnout, zadejte velké celočíselné hodnoty v souboru parametrů. Typy prostředků používají vlastní omezení pro celočíselné vlastnosti.

Plovoucí desetinná čárka, desítkové nebo binární formáty se v současné době nepodporují.

Objekty

Objekty začínají levou složenou závorkou ({) a končí pravou složenou závorkou (}). V Bicep lze objekt deklarovat na jednom řádku nebo více řádcích. Každá vlastnost v objektu se skládá z klíče a hodnoty. Klíč a hodnota jsou oddělené dvojtečku (:). Objekt umožňuje libovolnou vlastnost libovolného typu. Čárky (,) se používají mezi vlastnostmi pro jednořádkové deklarace, ale nepoužívají se mezi vlastnostmi pro deklarace více řádků. Můžete kombinovat a odpovídat jednořádkovým a víceřádkovým deklaracím. Deklarace víceřádkového řádku vyžaduje rozhraní příkazového řádku Bicep verze 0.7.X nebo vyšší.

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}

V Bicep jsou uvozovky volitelně povolené u klíčů vlastností objektu:

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

V předchozím příkladu se uvozovky používají, když klíče vlastností objektu obsahují speciální znaky. Například mezera, -nebo .. Následující příklad ukazuje, jak používat interpolaci v klíčích vlastností objektu.

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

Přístup k vlastnostem objektu se používá pro přístup k vlastnostem objektu. Jsou vytvořené pomocí operátoru . .

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

Přístupové objekty vlastností lze použít s libovolným objektem, včetně parametrů a proměnných typů objektů a literálů objektů. Použití přístupového objektu vlastnosti ve výrazu jiného typu než objektu je chyba.

Syntaxi [] můžete také použít pro přístup k vlastnosti. Následující příklad vrátí Development.

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

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

Ve formátu JSON je objekt neuspořádanou kolekcí párů klíč/hodnota nula nebo více. Řazení se může lišit v závislosti na implementacích. Například funkce Bicep items() seřadí objekty v abecedním pořadí. Na jiných místech lze původní řazení zachovat. Kvůli tomuto ne determinismu nepoužívejte žádné předpoklady týkající se řazení klíčů objektů při psaní kódu, které interaguje s parametry nasazení a výstupy.

Při přístupu k neexistující vlastnosti objektu se zobrazí následující chyba:

The language expression property 'foo' doesn't exist

Abyste se vyhnuli výjimce, můžete použít logický operátor And, jak je znázorněno v následujícím příkladu:

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

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

Řetězce

V Bicep jsou řetězce označené jednoduchými uvozovkami a musí být deklarovány na jednom řádku. Jsou povoleny všechny znaky Unicode s kódovými body mezi 0 a 10FFFF .

param exampleString string = 'test value'

Následující tabulka uvádí sadu vyhrazených znaků, které musí být uchváceny zpětným lomítkem (\) znakem:

Řídicí sekvence	Reprezentovaná hodnota	Notes
`\\`	`\`
`\'`	`'`
`\n`	vedení (LF)
`\r`	návrat na začátek řádku (CR)
`\t`	znak tabulátoru
`\u{x}`	Bod kódu Unicode `x`	x představuje šestnáctkovou hodnotu bodu kódu mezi 0 a 10FFFF (včetně). Počáteční nuly jsou povolené. Body kódu nad FFFF se vygenerují jako náhradní pár.
`\$`	`$`	Pouze utéct, když následuje `{`.

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

Všechny řetězce v Bicep podporují interpolaci. Chcete-li vložit výraz, obklopte ho ${ a }. Odkazované výrazy nemohou přesahovat více řádků.

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

Víceřádkové řetězce

V Bicep jsou víceřádkové řetězce definovány mezi třemi jednoduchými uvozovkami (''') následovanými volitelně novým řádkem (levou sekvencí) a třemi jednoduchými uvozovkami (''' - pravou sekvencí). Znaky zadané mezi levou a pravou sekvencí se čtou doslovně a nejsou nutné ani nejsou možné.

Poznámka:

Vzhledem k tomu, že analyzátor Bicep čte všechny znaky tak, jak je, v závislosti na koncích řádku souboru Bicep lze nové řádky interpretovat jako buď \r\n nebo \n.

Interpolace se v současné době nepodporuje ve víceřádkových řetězcích. Kvůli tomuto omezení možná budete muset místo interpolace použít concat funkci.

Víceřádkové řetězce obsahující ''' nejsou podporovány.

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

Zabezpečení řetězců a objektů

Zabezpečený řetězec používá stejný formát jako řetězec a zabezpečený objekt používá stejný formát jako objekt. Pomocí Bicep přidáte @secure()dekorátor do řetězce nebo objektu.

Když nastavíte parametr na zabezpečený řetězec nebo zabezpečený objekt, hodnota parametru se neuloží do historie nasazení a nezaprotokoluje se. Pokud ale tuto zabezpečenou hodnotu nastavíte na vlastnost, která neočekává bezpečnou hodnotu, nebude tato hodnota chráněna. Pokud například nastavíte zabezpečený řetězec na značku, uloží se tato hodnota jako prostý text. Používejte zabezpečené řetězce pro hesla a tajné kódy.

Následující příklad ukazuje dva zabezpečené parametry:

@secure()
param password string

@secure()
param configValues object

Přiřaditelnost datového typu

V Bicep je možné přiřadit hodnotu jednoho typu (typ zdroje) jinému typu (cílovému typu). Následující tabulka uvádí, který typ zdroje (uvedený vodorovně) může nebo nemůže být přiřazen k jakému cílovému typu (uvedený svisle). V tabulce znamená X přiřaditelné, prázdné místo znamená nepřiřazovatelné a ? znamená to pouze v případě, že jsou typy kompatibilní.

Typy	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	pojmenovaný prostředek	pojmenovaný modul	`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`											?
pojmenovaný prostředek	X						?		?
pojmenovaný modul	X						?			?

Další kroky

Další informace o struktuře a syntaxi bicep najdete v tématu Struktura souborů Bicep.