Megosztás a következőn keresztül:

Adattípusok a Bicepben

  • Cikk

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

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öt deklarálhat egy sorban vagy több sorban. A vesszőket (,) az egysoros deklarációk értékei között használják, de többsoros deklarációkban nem használják őket. 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.

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 egy egész számokat tartalmazó tömböt és egy különböző típusú tömböt mutat be.

var integerArray = [
  1
  2
  3
]

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

A Bicep tömbjei nullán alapulnak. 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. 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álja az Or logikai operátort, ahogyan az a következő példában látható:

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

Lásd: Logikai függvény

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ásukkor az üzembe helyezéshez használt SDK vagy parancssori eszköz korlátozhatja az értékek tartományát. Ha például a PowerShell használatával telepíti a Bicep-et, az egész számok tí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 egy olyan egész számkonstanstípust támogat, amely egy pontos egész számot tartalmazó adott értékre hivatkozik. Az alábbi példában 1 egy egész számkonstanstípus szerepel, és foo csak az értékhez 1 rendelhető hozzá, más érték nem.

output foo 1 = 1

Az egész szám literáltípusát deklarálhatja beágyazottan, 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 az eredményekhez való hozzárendelés 2 BCP033-hibát eredményez: "Várt egy típusértéket1, de a megadott érték típusa 2bar ."

Az alábbi példa egy egész számkonstanstípust használ egyesítő típussal:

output bar 1 | 2 | 3 = 3

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

Lásd: Numerikus függvények.

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ó egyetlen sorban vagy több sorban. Egy objektum minden tulajdonsága egy kulcsból és egy é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, a többsoros deklarációk tulajdonságai között azonban 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. Ilyen például a szóköz vagy -.a . 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

Bármilyen objektumhoz használhat tulajdonságkiegészítőket, beleértve az objektumtípusok és objektumkonstansok paramétereit és változóit. A nem észlelés típusú kifejezéshez használt tulajdonság-tartozék hiba.

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- vagy értékpár rendezetlen gyűjteménye. A sorrend az implementációktól függően eltérő lehet. A Bicep items() függvény például betűrendbe rendezi az objektumokat. Más helyeken megőrizheti az eredeti sorrendet. Ennek a nemdeterminizmusnak köszönhetően 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

Lásd: Objektumfüggvények.

Sztringek

A Bicepben a sztringek egyetlen idézőjelekkel vannak megjelölve, és egyetlen sorban kell deklarálni őket. Minden Unicode-karakter, amely között 0 kódpontok vannak, és 10FFFF engedélyezettek.

param exampleString string = 'test value'

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

Menekülési sorozat Reprezentátott érték Jegyzetek
\\ \
\' '
\n Vonalcsatorna (LF)
\r Kocsivissza (CR)
\t Tabulátor karakter
\u{x} Unicode-kódpont x Az x érték hexadecimális kódpontértéket 010FFFF jelöl (mindkettőt beleértve). A kezdő nullák engedélyezettek. A fenti FFFF kódpontok helyettesítő párként jelennek meg.
\$ $ Csak akkor meneküljön, ha utána {következik . 
// evaluates to "what's up?"
var myVar = 'what\'s up?'

A Bicep egy adott sztringértékre hivatkozó sztringkonstanstípust támogat. Az alábbi példában red egy sztringkonstanstípus látható. Az értéket red csak a következőhöz redColorrendelheti hozzá:

output redColor 'red' = 'red'

Sztringkonstanstípust 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 az eredményekhez való hozzárendelés blue BCP033-hibát eredményez: "Várt egy típusértéketred, de a megadott érték típusa bluecolorBlue ."

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

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 Bicepben a többsoros sztringek három önálló idézőjel (''') között vannak definiálva, amelyeket opcionálisan egy új vonal (a nyitó sorozat) és három egyetlen idézőjel (''' a záró sorozat) követ. A nyitó és a záró sorozat között beírt karaktereket a rendszer szó szerint felolvassa. A menekülés nem szükséges vagy lehetséges.

Feljegyzés

A Bicep-elemző minden karaktert beolvas. A Bicep-fájl sorvégződéseitől függően a rendszer az új vonalakat a következőképpen értelmezi: vagy \r\n\n.

Az interpoláció jelenleg nem támogatott többsoros sztringekben. Emiatt a korlátozás miatt előfordulhat, hogy az 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ípuskészletbő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 elválasztja a feltételt or használó egyes altípusokat. A szintaxis a | b például azt jelenti, hogy egy érvényes hozzárendelés lehet vagy ab. 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)[]

A típusegyesületeknek egyetlen Azure Resource Manager-típusra, például string, intvagy bool. Ellenkező esetben a BCP294 hibakód jelenik meg. Példa:

type foo = 'a' | 1

Bármilyen típusú kifejezést 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ípusokat, amelyek több típus egyikét jelentő értéket jelölnek. 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 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 értékét. 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 típusa foovan, akkor a rendszer a típus használatával érvényesíti.FooConfig Hasonlóképpen, ha a paraméter típusú bar, akkor a rendszer a típus használatával érvényesíti azt BarConfig . Ez a minta más típusokra is vonatkozik.

Az egyesítő típus néhány korlátozással rendelkezik:

  • Az egyesítő típusoknak egyetlen Azure Resource Manager-típusra 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 sztringek ugyanazt a formátumot használják, mint a sztring, a biztonságos objektumok pedig ugyanazt a formátumot használják, 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 vagy naplózva. Ha ezt a biztonságos értéket olyan tulajdonságra állítja be, amely nem számít biztonságos értékre, az érték nem 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 típus (forrástípus) értékét rendelheti egy másik típushoz (céltípushoz). Az alábbi táblázat azt mutatja be, hogy melyik forrástípust (vízszintesen felsorolva) lehet vagy nem lehet hozzárendelni a céltípushoz (függőlegesen felsorolva). A táblázatban az X azt jelenti, hogy hozzárendelhető, az üres terület nem rendelhető, a ? pedig 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úrája és szintaxisa című témakörben olvashat.