Sdílet prostřednictvím

Datové typy v Bicep

  • Článek

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.

Pole

Pole začínají levou závorkou ([) a končí pravou závorkou (]). V bicep můžete deklarovat pole na jednom řádku nebo na 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 pole různých typů.

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, použijte 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

Viz Logická funkce

Celá čísla

Pokud zadáte celočíselné hodnoty, nepoužívejte uvozovky.

param exampleInt int = 1

Celá čísla Bicep jsou 64bitová celá čísla. Když se předají jako vložené parametry, může sada SDK nebo nástroj příkazového řádku, který používáte pro nasazení, omezit rozsah hodnot. Pokud například k nasazení Bicep použijete 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 1 je celočíselnou literálovou hodnotou a foo dá se přiřadit pouze hodnota 1 a žádná jiná hodnota.

output foo 1 = 1

Integer literál můžete deklarovat buď vloženého, 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

V předchozím příkladu 2 přiřazení k výsledku dojde k bar chybě BCP033: "Očekává se hodnota typu1, ale zadaná hodnota je typu2."

Následující příklad používá celočíselnou literálový typ se sjednocovacího typu:

output bar 1 | 2 | 3 = 3

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

Viz Číselné funkce.

Objekty

Objekty začínají levou složenou závorkou ({) a končí pravou složenou závorkou (}). V Bicep můžete deklarovat objekt na jednom řádku nebo ve 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. Příklady jsou 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. Konstruují se 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í můžete použít s libovolným objektem, včetně parametrů a proměnných typů objektů a literálů objektů. Přístupové objekty vlastností použité ve výrazu typu bezobjektu jsou 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 nebo 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 můžete zachovat původní řazení. Kvůli tomuto nedeterminismu nepoužívejte žádné předpoklady týkající se řazení klíčů objektů při psaní kódu, který komunikuje 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

Viz Funkce objektu.

Řetězce

V Bicep jsou řetězce označené jednoduchými uvozovkami a je nutné je deklarovat na jednom řádku. Všechny znaky Unicode s body kódu mezi 0 a 10FFFF jsou povolené.

param exampleString string = 'test value'

Následující tabulka uvádí sadu vyhrazených znaků, které je nutné uvést pomocí zpětného lomítka (\) znaku:

Řídicí sekvence Reprezentovaná hodnota Notes
\\ \
\' '
\n Podávání ČAR (LF)
\r Návrat na začátek řádku (CR)
\t Znak tabulátoru
\u{x} Bod kódu Unicode x Představuje x šestnáctkovou hodnotu bodu kódu mezi 0 a 10FFFF (včetně). Počáteční nuly jsou povolené. Výše uvedené FFFF body kódu se vygenerují jako náhradní dvojice.
\$ $ 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 red je řetězcový literál typu. Hodnotu můžete přiřadit red pouze k redColor.

output redColor 'red' = 'red'

Řetězcový literál můžete 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'

V předchozím příkladu blue přiřazení k výsledku dojde k colorBlue chybě BCP033: "Očekává se hodnota typured, ale zadaná hodnota je typublue."

Následující příklad ukazuje typ řetězcového literálu, který se používá 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 (''' je pravá sekvence). Znaky zadané mezi levou a pravou sekvencí jsou doslovné. Escaping není nezbytný nebo možný.

Poznámka:

Analyzátor Bicep čte všechny znaky tak, jak je. V závislosti na zakončení řádků souboru Bicep se nové řádky interpretují 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, které obsahují ''' , nejsou podporované.

// 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, který se skládá 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, které používají podmínku or . Syntaxe a | b například 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 Azure Resource Manageru, například string, intnebo bool. Jinak se zobrazí kód chyby BCP294 . Příklad:

type foo = 'a' | 1

Libovolný výraz typu můžete 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í sjednocovaný datový typ, který se používá k reprezentaci hodnoty, která může být jedním z několika typů. K deklaraci vlastní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. Například v předchozím příkladu, pokud serviceConfig je parametr typu foo, je ověřen pomocí FooConfig typu. Podobně platí, že pokud je parametr typu bar, ověří se pomocí tohoto BarConfig typu. Tento vzor platí také pro jiné typy.

Typ sjednocení má určitá omezení:

  • Sjednocovat typy musí být znovu na jeden typ Azure Resource Manageru. 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 můžete 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 tuto zabezpečenou hodnotu nastavíte na vlastnost, která neočekává bezpečnou hodnotu, tato hodnota není 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 můžete přiřadit hodnotu jednoho typu (typ zdroje) jinému typu (cílovému typu). Následující tabulka ukazuje, který typ zdroje (uvedený vodorovně) můžete nebo nemůžete přiřadit k jakému cílovému typu (uvedený svisle). X v tabulce znamená přiřaditelné, prázdné místo znamená nepřiřazovatelné a ? znamená pouze v případě, že jsou typy kompatibilní.

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

Související obsah

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