Adattípusok a Bicepben

Cikk
11/08/2023

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
Objektum
secureObject – a Bicep dekorátora jelzi
secureString – a bicep-i dekoratőr jelzi
Karakterlánc

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

Egy tömbben minden elemet bármilyen típus jelöl. 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-ben az egész számok 64 bites egész számok. Beágyazott paraméterekként való átadáskor az értékek tartományát korlátozhatja az üzembe helyezéshez használt SDK vagy parancssori eszköz. 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 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 ö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.

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

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

További lépések

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