Gegevenstypen in Bicep

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
• snaar

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

Elk matrixelement kan van elk type zijn. 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 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

Bicep-gehele getallen zijn 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 gebruikt voor implementatie. 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.

Bicep ondersteunt het letterlijke type geheel getal dat verwijst naar een specifieke waarde die een exact geheel getal is. In het volgende voorbeeld is 1 een letterlijk geheel getal. Foo kan alleen de waarde 1 en geen andere waarde worden toegewezen.

output foo 1 = 1

Een letterlijk geheel getal kan inline worden gedeclareerd, zoals wordt weergegeven in het vorige voorbeeld of in een type instructie.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

In het voorgaande voorbeeld resulteert het toewijzen van 2 aan balk in een BCP033-fout : verwacht een waarde van het type 1, maar de opgegeven waarde is van het type 2.

In het volgende voorbeeld ziet u het letterlijke type geheel getal met samenvoegingstype:

output bar 1 | 2 | 3 = 3

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

Bicep ondersteunt het letterlijke tekenreekstype dat verwijst naar een specifieke tekenreekswaarde. In het volgende voorbeeld is rood een letterlijk tekenreekstype, kan redColor alleen de waarde rood en geen andere waarde toewijzen.

output redColor 'red' = 'red'

Een letterlijk tekenreekstype kan inline worden gedeclareerd, zoals wordt weergegeven in het voorgaande voorbeeld of in een type instructie.

type redColor = 'red'

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

In het voorgaande voorbeeld resulteert het toewijzen van blauw aan colorBlue in een BCP033-fout: verwacht een waarde van het type 'rood', maar de opgegeven waarde is van het type 'blauw'.

In het volgende voorbeeld ziet u het letterlijke type tekenreeks met samenvoegingstype:

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

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

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

Samenvoegtypen

In Bicep maakt een samenvoegtype het mogelijk om een gecombineerd type te maken dat bestaat uit een set subtypen. Een toewijzing is geldig als een van de afzonderlijke subtypetoewijzingen is toegestaan. Het | teken scheidt afzonderlijke subtypen met behulp van een of meer voorwaarden. Bijvoorbeeld de syntaxis 'a' | b betekent dat een geldige opdracht 'a' of 'b' kan zijn. Samenvoegtypen worden omgezet in de beperking voor toegestane waarden in Bicep, zodat alleen letterlijke waarden zijn toegestaan als leden. Samenvoegingen kunnen een willekeurig aantal letterlijk getypte expressies bevatten.

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

Type-samenvoegingen moeten worden herleid tot één ARM-type, zoals 'tekenreeks', 'int' of 'bool'. Anders krijgt u de BCP294-foutcode. Voorbeeld:

type foo = 'a' | 1

Elke typeexpressie kan worden gebruikt als subtype in een samenvoegingstypedeclaratie (tussen | tekens). De volgende voorbeelden zijn bijvoorbeeld allemaal geldig:

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

Aangepast gegevenstype voor samenvoeging

Bicep ondersteunt aangepast gegevenstype voor getagde samenvoeging, dat wordt gebruikt om een waarde te vertegenwoordigen die een van verschillende typen kan zijn. Als u een aangepast gegevenstype voor een getagde samenvoeging wilt declareren, kunt u een @discriminator() decorator gebruiken. Bicep CLI versie 0.21.X of hoger is vereist voor het gebruik van deze decorator. De syntaxis is:

@discriminator('<property-name>')

De discriminator-decorator heeft één parameter, die een gedeelde eigenschapsnaam vertegenwoordigt voor alle leden van de vereniging. Deze eigenschapsnaam moet een vereiste letterlijke tekenreeks voor alle leden zijn en is hoofdlettergevoelig. De waarden van de gediscrimineerde eigenschap van de leden van de unie moeten uniek zijn op een niet-hoofdlettergevoelige manier.

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 }

De parameterwaarde wordt gevalideerd op basis van de gediscrimineerde eigenschapswaarde. Als in het voorgaande voorbeeld bijvoorbeeld de parameter serviceConfig van het type foo is, wordt deze gevalideerd met het FooConfig-type . Als de parameter van het typebalk is, wordt deze ook gevalideerd met het Type BarConfig. Dit patroon is ook van toepassing op andere typen.

Er zijn enkele beperkingen met het type samenvoeging.

• Samenvoegtypen moeten worden herleid tot één ARM-type (Azure Resource Manager). De volgende definitie is ongeldig:

  type foo = 'a' | 1
  

• Alleen letterlijke gegevens zijn toegestaan als leden.

• Alle letterlijke waarden moeten van hetzelfde primitieve gegevenstype zijn (bijvoorbeeld alle tekenreeksen of alle gehele getallen).

De syntaxis van het samenvoegtype kan worden gebruikt in door de gebruiker gedefinieerde gegevenstypen.

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	error	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.