Adattípusok a Bicepben

Ez a cikk a Bicepben támogatott adattípusokat ismerteti. Egyéni adattípusok definiálásához tekintse meg a felhasználó által definiált adattípusokat.

Támogatott típusok

A Bicepben az alábbi adattípusokat használhatja:

• tömb
• Bool
• Int
• tárgy
• secureObject – a Bicep dekorátora jelzi
• secureString – a bicep-i dekoratőr jelzi
• húr

Tömbök

A tömbök bal oldali szögletes zárójeltel ([) kezdődnek, és jobb oldali szögletes zárójeltel (]) végződnek. A Bicepben egy tömb deklarálható egysoros vagy több sorban. A vesszők (,) az egysoros deklarációk értékei között használatosak, de többsoros deklarációkban nem. Az egysoros és a többsoros deklarációk kombinálhatók és egyeztethetők. A többsoros deklarációhoz a Bicep CLI 0.7.X-es vagy újabb verziója szükséges.

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

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

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

Minden tömbelem bármilyen típusú lehet. Lehet olyan tömb, amelyben minden elem ugyanaz az adattípus, vagy egy tömb, amely különböző adattípusokat tartalmaz.

Az alábbi példa egész számokat és tömbtípusokat mutat be.

var integerArray = [
  1
  2
  3
]

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

A Bicep tömbjei nulla alapúak. Az alábbi példában a kifejezés exampleArray[0] 1-et értékel ki, és exampleArray[2] 3-ra értékel. Az indexelő indexe lehet egy másik kifejezés is. A kifejezés exampleArray[index] kiértékelése 2. Az egész szám indexelői csak tömbtípusok kifejezésében engedélyezettek.

var index = 1

var exampleArray = [
  1
  2
  3
]

A következő hibaüzenet jelenik meg, ha az index túllépi a határokat:

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

A kivétel elkerülése érdekében használhatja a Vagy logikai operátort az alábbi példában látható módon:

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

Logikai érték

Logikai értékek megadásakor használja true vagy false. Ne vegye körül az értéket idézőjelekkel.

param exampleBool bool = true

Egész számok

Egész számértékek megadásakor ne használjon idézőjeleket.

param exampleInt int = 1

A Bicep-egész számok 64 bites egész számok. Beágyazott paraméterekként való átadáskor az értékek tartományát az üzembe helyezéshez használt SDK vagy parancssori eszköz korlátozhatja. Ha például a PowerShell-lel üzembe helyez egy Bicep-et, az egész számtípusok a -2147483648 és a 2147483647 között mozoghatnak. A korlátozás elkerülése érdekében adjon meg nagy egész számértékeket egy paraméterfájlban. Az erőforrástípusok a saját korlátaikat alkalmazzák az egész számok tulajdonságaira.

A Bicep támogatja az egész szám konstanstípusát, amely egy adott értékre hivatkozik, amely egy pontos egész szám. Az alábbi példában az 1 egész szám konstans típusú, a foo csak az 1 értéket rendelheti hozzá, más értéket nem.

output foo 1 = 1

Az egész szám literáltípusa inline deklarálható az előző példában vagy egy type utasításban látható módon.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

Az előző példában a 2 sávhoz való hozzárendelés BCP033-hibát eredményez – "1" típusú értéket várt, de a megadott érték "2" típusú.

Az alábbi példa az egész szám konstanstípusának egyesítő típussal való használatát mutatja be:

output bar 1 | 2 | 3 = 3

A lebegőpontos, tizedes vagy bináris formátumok jelenleg nem támogatottak.

Objektumokat

Az objektumok bal oldali kapcsos zárójeltel ({) kezdődnek, és jobb oldali kapcsos zárójeltel (}) végződnek. A Bicepben egy objektum deklarálható egy sorban vagy több sorban. Egy objektum minden tulajdonsága kulcsból és értékből áll. A kulcsot és az értéket kettőspont (:kettőspont) választja el egymástól. Az objektumok bármilyen típusú tulajdonságot engedélyeznek. A vesszőket (,) az egysoros deklarációk tulajdonságai között használják, de a többsoros deklarációk tulajdonságai között nem. Egysoros és többsoros deklarációk kombinálhatók és egyeztethetők. A többsoros deklarációhoz a Bicep CLI 0.7.X-es vagy újabb verziója szükséges.

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}

A Bicep-ben az idézőjelek opcionálisan engedélyezve vannak az objektumtulajdonság-kulcsokon:

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

Az előző példában idézőjeleket használunk, ha az objektumtulajdonság-kulcsok speciális karaktereket tartalmaznak. Például szóköz, "-" vagy ".". Az alábbi példa bemutatja, hogyan használható az interpoláció az objektumtulajdonság-kulcsokban.

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

A tulajdonságkiegészítők egy objektum tulajdonságainak elérésére szolgálnak. Az operátorral vannak felépítve . .

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

A tulajdonságkiegészítők bármilyen objektummal használhatók, beleértve az objektumtípusok és objektumkonstansok paramétereit és változóit. Hiba, ha tulajdonságkiegészítőt használ egy nem objektum típusú kifejezésen.

A szintaxissal [] is hozzáférhet egy tulajdonsághoz. Az alábbi példa ad Developmentvissza.

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

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

A JSON-ban az objektum nulla vagy több kulcs/érték pár rendezetlen gyűjteménye. A rendezés a megvalósítástól függően eltérő lehet. A Bicep items() függvény például betűrendbe rendezi az objektumokat. Más helyeken az eredeti sorrend megőrizhető. Emiatt a nem determinizmus miatt ne feltételezze az objektumkulcsok sorrendjét a kód írásakor, amely az üzembehelyezési paraméterekkel és kimenetekkel kommunikál.

A következő hibaüzenet jelenik meg egy objektum nem meglévő tulajdonságának elérésekor:

The language expression property 'foo' doesn't exist

A kivétel elkerülése érdekében használhatja a And logikai operátort az alábbi példában látható módon:

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

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

Sztringek

A Bicep-ben a sztringek egyedi idézőjelekkel vannak megjelölve, és egyetlen sorban kell deklarálni. Minden Unicode-karakter 0 és 10FFFF közötti kódpontokkal engedélyezett.

param exampleString string = 'test value'

Az alábbi táblázat felsorolja azokat a fenntartott karaktereket, amelyeket fordított perjel (\) karakterrel kell feloldani:

Escape Sequence	Reprezentátott érték	Jegyzetek
\\	\
\'	'
\n	vonalcsatorna (LF)
\r	kocsivissza (CR)
\t	tabulátor karakter
\u{x}	Unicode-kódpont x	x egy 0 és 10FFFF közötti hexadecimális kódpontértéket jelöl (mindkettőt beleértve). A kezdő nullák engedélyezettek. Az FFFF fölötti kódpontok helyettesítő párként lesznek kibocsátva.
\$	$	Csak akkor meneküljön, ha utána {következik .

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

A Bicep támogatja az adott sztringértékre hivatkozó sztringkonstanstípust. Az alábbi példában a piros egy sztringkonstanstípus, a redColor csak a piros értéket rendelheti hozzá, más értéket nem.

output redColor 'red' = 'red'

A sztringkonstanstípus deklarálható beágyazottan, az előző példában vagy egy type utasításban látható módon.

type redColor = 'red'

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

Az előző példában a blue colorBlue-hez való hozzárendelése BCP033-hibát eredményez – "piros" típusú értéket várt, de a megadott érték "kék" típusú.

Az alábbi példa sztringkonstanstípust mutat be egyesítő típussal:

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

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

A Bicep összes sztringje támogatja az interpolációt. Egy kifejezés beszúrásához vegye körül és }.${ A hivatkozott kifejezések nem terjedhetnek át több sorra.

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

Többsoros sztringek

A Bicep-ben a többsoros sztringek három egy idézőjel karakter () között vannak definiálva,''' amelyeket opcionálisan egy új vonal (a nyitó sorozat) és három egy idézőjel (''' - a záró sorozat) követ. A nyitó és a záró sorozat között beírt karakterek szó szerint olvashatók, és nincs szükség vagy lehetséges menekülésre.

Feljegyzés

Mivel a Bicep-elemző az összes karaktert beolvassa, a Bicep-fájl sorvégződéseitől függően az új vonalak bármelyikként \r\n vagyként \nértelmezhetők.

Az interpoláció jelenleg nem támogatott többsoros sztringekben. A korlátozás miatt előfordulhat, hogy interpoláció helyett a concat függvényt kell használnia.

A többsoros sztringek ''' nem támogatottak.

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

Egyesítő típusok

A Bicep-ben az egyesítő típus lehetővé teszi egy altípusokból álló kombinált típus létrehozását. A hozzárendelés akkor érvényes, ha az egyes altípusú hozzárendelések bármelyike engedélyezett. A | karakter egy vagy több feltétel használatával választja el az egyes altípusokat. Például az "a" szintaxis | A "b" azt jelenti, hogy egy érvényes hozzárendelés lehet "a" vagy "b". Az egyesítő típusok a Bicep megengedett értékkorlátjába vannak lefordítva, így tagokként csak a literálok engedélyezettek. Az egyesítők tetszőleges számú literál típusú kifejezést tartalmazhatnak.

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

Bármely típuskifejezés használható altípusként egy egyesítő típusú deklarációban (karakterek között | ). Az alábbi példák például mind érvényesek:

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

Egyéni címkével ellátott egyesítő adattípus

A Bicep támogatja az egyéni címkézett egyesítő adattípust, amely egy olyan érték megjelenítésére szolgál, amely több különböző típus egyike lehet. Egyéni címkézett egyesítő adattípus deklarálásához használhat deklarátort @discriminator() . A dekorátor használatához a Bicep CLI 0.21.X-es vagy újabb verziója szükséges. A szintaxis a következő:

@discriminator('<property-name>')

A diszkriminatív dekorátor egyetlen paramétert vesz fel, amely az összes szakszervezeti tag közös tulajdonnevét jelöli. Ennek a tulajdonságnévnek kötelező sztringkonstansnak kell lennie az összes tagon, és megkülönbözteti a kis- és nagybetűk megkülönböztetése. A szakszervezeti tagok hátrányos megkülönböztetett tulajdonságának értékeinek egyedinek kell lenniük kis- és nagybetűket nem megkülönböztető módon.

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 }

A paraméter értéke a megkülönböztető tulajdonság értéke alapján lesz érvényesítve. Az előző példában például, ha a serviceConfig paraméter foo típusú, akkor a rendszer a FooConfig típussal érvényesíti. Hasonlóképpen, ha a paraméter típussávból áll, akkor a BarConfig típussal lesz érvényesítve. Ez a minta más típusokra is vonatkozik.

Az egyesítő típusra bizonyos korlátozások vonatkoznak.

• Az egyesítő típusoknak egyetlen Azure Resource Manager-típusra (ARM) kell visszavezetni. A következő definíció érvénytelen:

  type foo = 'a' | 1
  

• Tagokként csak a literálok engedélyezettek.

• Minden literálnak azonos primitív adattípusúnak kell lennie (például minden sztringnek vagy egész számnak).

Az egyesítő típus szintaxisa a felhasználó által definiált adattípusokban használható.

Biztonságos sztringek és objektumok

A biztonságos sztring formátuma megegyezik a sztring formátumával, a biztonságos objektum pedig ugyanazt a formátumot használja, mint az objektum. A Bicep használatával a dekoratőrt egy sztringhez vagy objektumhoz adhatja hozzá @secure() .

Ha egy paramétert biztonságos sztringre vagy biztonságos objektumra állít be, a paraméter értéke nem lesz mentve az üzembe helyezési előzményekbe, és nem lesz naplózva. Ha azonban a biztonságos értéket olyan tulajdonságra állítja be, amely nem számít biztonságos értékre, az érték nem lesz védett. Ha például egy biztonságos sztringet egy címkére állít be, az érték egyszerű szövegként lesz tárolva. Használjon biztonságos sztringeket jelszavakhoz és titkos kódokhoz.

Az alábbi példa két biztonságos paramétert mutat be:

@secure()
param password string

@secure()
param configValues object

Adattípus-hozzárendelés

A Bicepben egy adott típusú (forrástípusú) érték hozzárendelhető egy másik típushoz (céltípushoz). Az alábbi táblázat azt mutatja be, hogy melyik (vízszintesen felsorolt) forrástípust lehet vagy nem lehet hozzárendelni a céltípushoz (függőlegesen felsorolva). A táblában hozzárendelhető, üres terület azt jelenti, X hogy nem rendelhető hozzá, és ? csak akkor, ha a típusok kompatibilisek.

Típusok	any	error	string	number	int	bool	null	object	array	elnevezett erőforrás	elnevezett 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												?
elnevezett erőforrás	X							?		?
elnevezett modul	X							?			?

Következő lépések

A Bicep szerkezetéről és szintaxisáról a Bicep-fájlstruktúra című témakörben olvashat.