Datové typy v Bicep

Článek
08/20/2024

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

Každý prvek pole může být libovolného typu. 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

Celá čísla Bicep jsou 64bitová celá čísla. Při předání jako vložených parametrů 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.

Bicep podporuje celočíselnou literálovou hodnotu, která odkazuje na konkrétní hodnotu, která je přesné celé číslo. V následujícím příkladu je 1 celočíselnou literálovým typem, foo lze přiřadit pouze hodnotu 1 a žádnou jinou hodnotu.

output foo 1 = 1

Celočíselná literálová hodnota může být deklarována buď jako vložená, jak je znázorněno v předchozím příkladu type , nebo v příkazu.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

Přiřazením 2 k pruhu v předchozím příkladu dojde k chybě BCP033 – očekává se hodnota typu 1, ale zadaná hodnota je typu 2.

Následující příklad ukazuje použití celočíselného literálového typu se sjednocovacího typu:

output bar 1 | 2 | 3 = 3

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

Bicep podporuje typ řetězcového literálu, který odkazuje na konkrétní řetězcovou hodnotu. V následujícím příkladu je červený typ řetězcového literálu, redColor může být přiřazena pouze červená hodnota a žádná jiná hodnota.

output redColor 'red' = 'red'

Řetězcový literál lze deklarovat buď jako vložený, jak je znázorněno v předchozím příkladu type , nebo v příkazu.

type redColor = 'red'

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

Přiřazením modré barvy v předchozím příkladu dojde k chybě BCP033 – očekává se hodnota typu "červená", ale zadaná hodnota je typu "modrá".

Následující příklad ukazuje použití řetězcového literálového typu se sjednocovacím typem:

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

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

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

Typy sjednocení

V Bicep umožňuje sjednocovací typ vytvoření kombinovaného typu sestávajícího ze sady podtypů. Přiřazení je platné, pokud je povolená některá z jednotlivých přiřazení podtypů. Znak | odděluje jednotlivé podtypy pomocí podmínky. Například syntaxe "a" | "b" znamená, že platné přiřazení může být buď "a", nebo "b". Typy sjednocení se překládají do omezení povolené hodnoty v Bicep, takže jako členy jsou povoleny pouze literály. Sjednocení můžou obsahovat libovolný počet výrazů typu literál.

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)[]

Sjednocení typů musí být znovu na jeden typ ARM, například řetězec, int nebo bool. Jinak se zobrazí kód chyby BCP294 . Příklad:

type foo = 'a' | 1

Libovolný výraz typu lze použít jako podtyp v deklaraci typu sjednocení (mezi | znaky). Například následující příklady jsou platné:

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

Vlastní sjednocovaný datový typ

Bicep podporuje vlastní označený sjednocovaný datový typ, který se používá k reprezentaci hodnoty, která může být jedním z několika různých typů. K deklaraci vlastního označeného sjednocovacího datového @discriminator() typu můžete použít dekorátor. K použití tohoto dekorátoru se vyžaduje rozhraní příkazového řádku Bicep verze 0.21.X nebo vyšší . Syntaxe je:

@discriminator('<property-name>')

Nediskriminační dekorátor přebírá jeden parametr, který představuje název sdílené vlastnosti mezi všemi členy sjednocení. Tento název vlastnosti musí být povinný řetězcový literál pro všechny členy a rozlišují se malá a velká písmena. Hodnoty diskriminované vlastnosti členů sjednocení musí být jedinečné způsobem bez rozlišování malých a malých písmen.

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 }

Hodnota parametru je ověřena na základě diskriminované hodnoty vlastnosti. Pokud je například v předchozím příkladu parametr serviceConfig typu foo, ověří se pomocí typu FooConfig . Podobně platí, že pokud je parametr typu pruh, ověří se pomocí typu BarConfig . Tento model platí i pro jiné typy.

U typu sjednocení existují určitá omezení.

Sjednocovat typy musí být znovu na jeden typ Azure Resource Manageru (ARM). Následující definice je neplatná:
```
type foo = 'a' | 1
```
Jako členy jsou povoleny pouze literály.
Všechny literály musí být stejného primitivního datového typu (například všechny řetězce nebo všechna celá čísla).

Syntaxi sjednocovacího typu lze použít v uživatelsky definovaných datových typech.

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.

Sdílet prostřednictvím