Sdílet prostřednictvím

Datové typy v Bicep

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.

Jakýkoliv

U verze Bicep v0.38.3 a novější any je typ bicep permisivním typem, který zakazuje kontrolu typů kompilace pro přidružený symbol. Hodnota typu any může obsahovat data libovolného typu, včetně string, intbool, array, , , objectnebo složitých výrazů.

param foo any
output bar any = foo

V předchozím příkladu foo může přijmout libovolný typ hodnoty a bar výstupem stejné hodnoty, jako foo je bez ohledu na jeho typ.

Vzhledem k tomu any , že bezpečnost typů Bicep obchází, měla by být použita pouze v případě, že přesný typ nelze předem určit. Například při předávání dat přes modul, který zpracovává více datových obrazců nebo při práci s nezatypovaným vstupem JSON.

Použití any nástroje Bicep je méně předvídatelné a může vést k chybám za běhu. Pokud je to možné, upřednostněte konkrétní typy nebo sjednocení očekávaných typů, aby se zachovala podpora ověřování a technologie IntelliSense. Žádné explicitní pravidlo linteru pomáhá identifikovat a nedoporučuje použití any typu v souborech Bicep.

Pole

Pole v Bicep je uspořádaná kolekce hodnot, jako jsou řetězce, celá čísla, objekty nebo dokonce jiná pole, která se běžně používají k seskupení souvisejících položek, jako jsou názvy prostředků, nastavení konfigurace nebo parametry. Pole jsou užitečná pro uspořádání dat nasazení, předávání seznamů prostředkům a iterování více hodnot.

Pole v Bicep jsou neměnná. Jakmile je deklarován, jejich obsah nelze změnit. Chcete-li pole "upravit", vytvořte nové pole pomocí funkcí, jako je concat, mapnebo filter.

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

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

param numbers int[] = [
  1
  2
  3
]

Pole v Bicep můžete deklarovat pomocí jednořádkové nebo víceřádkové syntaxe. Deklarace víceřádkového pole vyžadují rozhraní příkazového řádku Bicep verze 0.7.X nebo novější.

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

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

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

Jednořádková pole používají k oddělení hodnot čárky (,). Víceřádkové pole nepoužívají čárky mezi hodnotami. Podle potřeby můžete kombinovat jednořádkové a víceřádkové deklarace.

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.

var integerArray = [
  1
  2
  3
]

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

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

Pole v Bicep jsou založená na nule. K prvkům můžete přistupovat pomocí indexu:

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

Počínaje rozhraním příkazového řádku Bicep verze 0.34.x můžete použít array[^index] syntaxi pro přístup k prvkům z konce pole – ^1 odkazuje na poslední prvek, ^2 druhý až poslední atd.

var exampleArray = [1, 2, 3]

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

Pokud přistupujete k indexu, který je mimo hranice, zobrazí se chyba:

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

Pokud se chcete vyhnout výjimce mimo hranice, 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 novější.

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 Poznámky
\\ \
\' '
\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íceřádkový řetězec můžete definovat tak, že ho uzavřete do tří jednoduchých uvozovek ('''). Obsah řetězce se zachová přesně tak, jak je napsaný, takže řídicí znaky se nevyžadují. Oddělovač ''' nelze v řetězci zobrazit.

Řetězec může začínat bezprostředně za levou oddělovačem nebo na následujícím řádku. V obou případech výsledná hodnota neobsahuje úvodní nový řádek. Konce řádků se interpretují jako \r\n nebo \nv závislosti na formátu konce řádku souboru Bicep.

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

U rozhraní příkazového řádku Bicep verze v0.40.2 nebo vyšší se podporuje interpolace řetězců. Před levý oddělovač lze přidat volitelnou $ předponu, která umožňuje interpolaci řetězců pomocí standardní syntaxe Bicep ${...} . Pokud potřebujete zahrnout ${...} jako hodnotu literálu bez zapouzdření, můžete interpolaci řídit opakováním předpony $ . Interpolace se provádí pouze v případech, kdy počet $ předchozích ${...} znaků odpovídá počtu $ znaků použitých v počátečním oddělovači.

// evaluates to "interpolation\nis ${blocked}"
// note ${blocked} is part of the string, and is not evaluated as an expression
var myVar6 = '''interpolation
is ${blocked}'''

// evaluates to "this is a test"
var interpolated = 'a test'
var myVar7 = $'''
this is ${interpolated}'''

// evaluates to "this is a test\nthis is not ${interpolated}"
var interpolated = 'a test'
var myVar8 = $$'''
this is $${interpolated}
this is not ${interpolated}'''

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ý typ výrazu 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ý představuje hodnotu, 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 novější. 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.

Nullable typy

Libovolný primitivní nebo složitý typ null můžete vytvořit tak, že k názvu typu připojíte ? hodnotu null. To umožňuje, aby parametr, proměnná nebo výstup přijímaly hodnotu null jako platnou hodnotu. Příklad:

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

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

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

Když nastavíte parametr (nebo výstup) na zabezpečený řetězec nebo zabezpečený objekt, hodnota parametru (nebo výstupu) se neuloží do historie nasazení nebo se zaprotokoluje. Při použití příznaku --debug během nasazení jsou však zabezpečené hodnoty zaprotokolovány ve formátu prostého textu. 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

Další informace najdete v tématu Zabezpečené parametry a výstupy zabezpečení.

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

Další kroky

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

  • Last updated on