Gegevenstypen in Bicep

Artikel
11/08/2023

In dit artikel worden de gegevenstypen beschreven die worden ondersteund in Bicep. Zie Door de gebruiker gedefinieerde gegevenstypen om aangepaste gegevenstypen te definiëren.

Ondersteunde typen

Binnen een Bicep kunt u deze gegevenstypen gebruiken:

Array
bool
int
Object
secureObject - aangegeven door decorator in Bicep
secureString - aangegeven door decorator in Bicep
Tekenreeks

Matrices

Matrices beginnen met een linkerhaak ([) en eindigen met een rechterhaak (]). In Bicep kan een matrix worden gedeclareerd in één regel of meerdere regels. Komma's (,) worden gebruikt tussen waarden in declaraties met één regel, maar niet gebruikt in declaraties met meerdere regels. U kunt declaraties met één regel en meerdere regels combineren en vergelijken. Voor de declaratie met meerdere regels is Bicep CLI versie 0.7.X of hoger vereist.

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

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

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

In een matrix wordt elk item vertegenwoordigd door het type. U kunt een matrix hebben waarbij elk item hetzelfde gegevenstype is of een matrix met verschillende gegevenstypen.

In het volgende voorbeeld ziet u een matrix met gehele getallen en een matrix van verschillende typen.

var integerArray = [
  1
  2
  3
]

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

Matrices in Bicep zijn gebaseerd op nul. In het volgende voorbeeld wordt met de expressie exampleArray[0] 1 geëvalueerd en exampleArray[2] wordt 3 geëvalueerd. De index van de indexeerfunctie kan zelf een andere expressie zijn. De expressie exampleArray[index] resulteert in 2. Indexeerfuncties voor gehele getallen zijn alleen toegestaan voor expressies van matrixtypen.

var index = 1

var exampleArray = [
  1
  2
  3
]

U krijgt de volgende fout wanneer de index buiten de grenzen valt:

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

Als u deze uitzondering wilt voorkomen, kunt u de logische operator Of gebruiken, zoals wordt weergegeven in het volgende voorbeeld:

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

Booleaans

Wanneer u booleaanse waarden opgeeft, gebruikt true u of false. Plaats de waarde niet tussen aanhalingstekens.

param exampleBool bool = true

Gehele getallen

Gebruik bij het opgeven van gehele getallen geen aanhalingstekens.

param exampleInt int = 1

In Bicep zijn gehele getallen 64-bits gehele getallen. Wanneer de waarden als inlineparameters worden doorgegeven, kan het bereik van waarden worden beperkt door de SDK of het opdrachtregelprogramma dat u voor implementatie gebruikt. Wanneer u bijvoorbeeld PowerShell gebruikt om een Bicep te implementeren, kunnen gehele getallen variëren van -2147483648 tot 2147483647. Als u deze beperking wilt voorkomen, geeft u grote gehele getallen op in een parameterbestand. Resourcetypen passen hun eigen limieten toe voor gehele getallen.

Drijvende komma-, decimale of binaire indelingen worden momenteel niet ondersteund.

Objecten

Objecten beginnen met een linker brace ({) en eindigen met een rechter brace (}). In Bicep kan een object worden gedeclareerd in één regel of meerdere regels. Elke eigenschap in een object bestaat uit sleutel en waarde. De sleutel en waarde worden gescheiden door een dubbele punt (:). Een object staat elke eigenschap van elk type toe. Komma's (,) worden gebruikt tussen eigenschappen voor declaraties met één regel, maar niet gebruikt tussen eigenschappen voor declaraties met meerdere regels. U kunt declaraties met één regel en meerdere regels combineren. Voor de declaratie met meerdere regels is Bicep CLI versie 0.7.X of hoger vereist.

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}

In Bicep zijn aanhalingstekens optioneel toegestaan voor objecteigenschapssleutels:

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

In het voorgaande voorbeeld worden aanhalingstekens gebruikt wanneer de objecteigenschapssleutels speciale tekens bevatten. Bijvoorbeeld spatie, '-' of '.'. In het volgende voorbeeld ziet u hoe u interpolatie gebruikt in objecteigenschapssleutels.

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

Eigenschapstoegangsors worden gebruikt voor toegang tot eigenschappen van een object. Ze worden samengesteld met behulp van de . operator.

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

Eigenschapstoegangsors kunnen worden gebruikt met elk object, inclusief parameters en variabelen van objecttypen en letterlijke objecteigenschappen. Het gebruik van een eigenschapstoegangsfunctie voor een expressie van niet-objecttype is een fout.

U kunt ook de [] syntaxis gebruiken om toegang te krijgen tot een eigenschap. Het volgende voorbeeld retourneert Development.

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

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

In JSON is een object een niet-geordende verzameling van nul of meer sleutel-waardeparen. De volgorde kan verschillen, afhankelijk van de implementaties. De functie Bicep items() sorteert bijvoorbeeld de objecten in alfabetische volgorde. Op andere plaatsen kan de oorspronkelijke volgorde behouden blijven. Vanwege dit niet-determinisme vermijdt u veronderstellingen over de volgorde van objectsleutels bij het schrijven van code, die communiceert met implementatieparameters en uitvoer.

U krijgt de volgende fout bij het openen van een niet-bestaande eigenschap van een object:

The language expression property 'foo' doesn't exist

Als u de uitzondering wilt voorkomen, kunt u de logische operator En gebruiken, zoals wordt weergegeven in het volgende voorbeeld:

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

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

Tekenreeksen

In Bicep worden tekenreeksen gemarkeerd met enkele aanhalingstekens en moeten ze worden gedeclareerd op één regel. Alle Unicode-tekens met codepunten tussen 0 en 10FFFF zijn toegestaan.

param exampleString string = 'test value'

De volgende tabel bevat de set gereserveerde tekens die moeten worden ontsnapt door een backslash (\) teken:

Escape-reeks	Vertegenwoordigde waarde	Opmerkingen
`\\`	`\`
`\'`	`'`
`\n`	lijnfeed (LF)
`\r`	regelterugloop (CR)
`\t`	tabteken
`\u{x}`	Unicode-codepunt `x`	x vertegenwoordigt een hexadecimale codepuntwaarde tussen 0 en 10FFFF (beide inclusief). Voorloopnullen zijn toegestaan. Codepunten boven FFFF worden verzonden als surrogaatpaar.
`\$`	`$`	Alleen ontsnappen wanneer gevolgd door `{`.

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

Alle tekenreeksen in Bicep ondersteunen interpolatie. Als u een expressie wilt injecteren, omringt u deze door ${ en }. Expressies waarnaar wordt verwezen, kunnen niet meerdere regels omvatten.

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

Tekenreeksen met meerdere regels

In Bicep worden tekenreeksen met meerdere regels gedefinieerd tussen drie enkele aanhalingstekens (''') gevolgd door een nieuwe regel (de openingsreeks) en drie enkele aanhalingstekens (''' - de afsluitende reeks). Tekens die worden ingevoerd tussen de openings- en afsluitvolgorde, zijn de exacte bewoordingen voorgelezen en er is geen escape nodig of mogelijk.

Notitie

Omdat de Bicep-parser alle tekens leest, afhankelijk van de regeleinden van uw Bicep-bestand, kunnen nieuwe regels worden geïnterpreteerd als \r\n of \n.

Interpolatie wordt momenteel niet ondersteund in tekenreeksen met meerdere regels. Vanwege deze beperking moet u mogelijk de concat functie gebruiken in plaats van interpolatie.

Tekenreeksen met meerdere regels die bevatten ''' , worden niet ondersteund.

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

Tekenreeksen en objecten beveiligen

Beveiligde tekenreeks maakt gebruik van dezelfde indeling als tekenreeks en beveiligd object gebruikt dezelfde indeling als het object. Met Bicep voegt u de @secure()decorator toe aan een tekenreeks of object.

Wanneer u een parameter instelt op een beveiligde tekenreeks of beveiligd object, wordt de waarde van de parameter niet opgeslagen in de implementatiegeschiedenis en wordt deze niet geregistreerd. Als u deze beveiligde waarde echter instelt op een eigenschap die geen veilige waarde verwacht, wordt de waarde niet beveiligd. Als u bijvoorbeeld een beveiligde tekenreeks instelt op een tag, wordt die waarde opgeslagen als tekst zonder opmaak. Gebruik beveiligde tekenreeksen voor wachtwoorden en geheimen.

In het volgende voorbeeld ziet u twee beveiligde parameters:

@secure()
param password string

@secure()
param configValues object

Toewijsbaarheid van gegevenstype

In Bicep kan een waarde van één type (brontype) worden toegewezen aan een ander type (doeltype). In de volgende tabel ziet u welk brontype (horizontaal vermeld) wel of niet kan worden toegewezen aan welk doeltype (verticaal vermeld). In de tabel X betekent toewijzen, lege ruimte betekent niet toewijsbaar en ? betekent dit alleen als ze typen compatibel zijn.

Typen	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	benoemde resource	benoemde module	`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`											?
benoemde resource	X						?		?
benoemde module	X						?			?

Volgende stappen

Zie Bicep-bestandsstructuur voor meer informatie over de structuur en syntaxis van Bicep.