Delen via

Gegevenstypen in Bicep

  • Artikel

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

Matrices

Matrices beginnen met een linkerhaak ([) en eindigen met een rechterhaak (]). In Bicep kunt u een matrix in één regel of in meerdere regels declareren. Komma's (,) worden gebruikt tussen waarden in declaraties met één regel, maar worden niet gebruikt in 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.

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 de expressie 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, gebruikt u de logische operator Or, 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

Logische functie weergeven

Gehele getallen

Wanneer u gehele getallen opgeeft, gebruikt u geen aanhalingstekens.

param exampleInt int = 1

Bicep-gehele getallen zijn 64-bits gehele getallen. Wanneer ze worden doorgegeven als inlineparameters, kan het SDK- of opdrachtregelprogramma dat u voor implementatie gebruikt, het bereik van waarden beperken. Wanneer u bijvoorbeeld PowerShell gebruikt om 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 een letterlijk type geheel getal dat verwijst naar een specifieke waarde die een exact geheel getal is. In het volgende voorbeeld 1 is een letterlijk geheel getal en foo kan alleen de waarde 1 en geen andere waarde worden toegewezen.

output foo 1 = 1

U kunt een letterlijk type geheel getal inline declareren, 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 wordt het toewijzen 2 aan bar resultaten in een BCP033-fout : 'Verwacht een waarde van het type 1 , maar de opgegeven waarde is van het type 2'.

In het volgende voorbeeld wordt een letterlijk geheel getal gebruikt met een samenvoegtype:

output bar 1 | 2 | 3 = 3

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

Zie numerieke functies.

Objecten

Objecten beginnen met een linker brace ({) en eindigen met een rechter brace (}). In Bicep kunt u een object op één regel of in meerdere regels declareren. Elke eigenschap in een object bestaat uit een sleutel en een 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 worden 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. Voorbeelden zijn ruimte, -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

U kunt eigenschapstoegangsors gebruiken voor elk object, inclusief parameters en variabelen van objecttypen en letterlijke objecten. Een eigenschapstoegangsfunctie die wordt gebruikt voor een expressie van een 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- of waardeparen. De volgorde kan verschillen, afhankelijk van de implementaties. Met de functie Bicep items() worden de objecten bijvoorbeeld in alfabetische volgorde gesorteerd. Op andere plaatsen kunt u de oorspronkelijke volgorde behouden. Vanwege dit niet-determinisme vermijdt u eventuele veronderstellingen over de volgorde van objectsleutels wanneer u code schrijft, die communiceert met implementatieparameters en uitvoer.

U krijgt de volgende fout wanneer u toegang krijgt tot 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

Zie Objectfuncties.

Tekenreeksen

In Bicep worden tekenreeksen gemarkeerd met enkele aanhalingstekens en moet u deze op één regel declareren. 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 u moet ontsnappen met behulp van een backslash (\) teken:

Escape-reeks Vertegenwoordigde waarde Opmerkingen
\\ \
\' '
\n Lijnfeed (LF)
\r Regelterugloop (CR)
\t Tabteken
\u{x} Unicode-codepunt x De x waarde vertegenwoordigt een hexadecimale codepuntwaarde tussen 0 en 10FFFF (beide inclusief). Voorloopnullen zijn toegestaan. Codepunten hierboven FFFF worden verzonden als surrogaatpaar.
\$ $ Alleen ontsnappen wanneer gevolgd door {. 
// evaluates to "what's up?"
var myVar = 'what\'s up?'

Bicep ondersteunt een letterlijk tekenreekstype dat verwijst naar een specifieke tekenreekswaarde. In het volgende voorbeeld red is een letterlijk tekenreekstype. U kunt de waarde red alleen toewijzen aan redColor.

output redColor 'red' = 'red'

U kunt een letterlijk tekenreekstype inline declareren, zoals wordt weergegeven in het vorige voorbeeld of in een type instructie.

type redColor = 'red'

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

In het voorgaande voorbeeld wordt het toewijzen blue aan colorBlue resultaten in een BCP033-fout : 'Verwacht een waarde van het type red , maar de opgegeven waarde is van het type blue'.

In het volgende voorbeeld ziet u een letterlijk tekenreekstype dat wordt gebruikt met een 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 (''' is de afsluitende reeks). Tekens die worden ingevoerd tussen de openings- en afsluitvolgorde, worden letterlijk gelezen. Ontsnappen is niet nodig of mogelijk.

Notitie

De Bicep-parser leest alle tekens zoals is. Afhankelijk van de lijneinden van uw Bicep-bestand, worden nieuwe lijnen geïnterpreteerd als of \r\n \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 ''' niet worden 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 kunt u met een samenvoegtype een gecombineerd type maken dat bestaat uit een set subtypen. Een toewijzing is geldig als een van de afzonderlijke subtypetoewijzingen is toegestaan. Het | teken scheidt afzonderlijke subtypen die een or voorwaarde gebruiken. De syntaxis a | b betekent bijvoorbeeld dat een geldige toewijzing kan zijn a of b. 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 Azure Resource Manager-type, zoals string, intof bool. Anders krijgt u de BCP294-foutcode. Voorbeeld:

type foo = 'a' | 1

U kunt elke typeexpressie gebruiken 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 een aangepast gegevenstype voor een samenvoeging, dat wordt gebruikt om een waarde te vertegenwoordigen die een van de verschillende typen kan zijn. Als u een aangepast gegevenstype voor een 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 zijn voor alle leden 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 de parameter bijvoorbeeld van het type foois, wordt deze serviceConfig in het voorgaande voorbeeld gevalideerd met behulp van het FooConfig type. Als de parameter van het type baris, wordt deze ook gevalideerd met behulp van het BarConfig type. Dit patroon is ook van toepassing op andere typen.

Het type samenvoeging heeft enkele beperkingen:

  • Samenvoegtypen moeten worden herleid tot één Azure Resource Manager-type. 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).

U kunt de syntaxis van het samenvoegtype gebruiken 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 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 kunt u een waarde van het ene type (brontype) toewijzen aan een ander type (doeltype). In de volgende tabel ziet u welk brontype (horizontaal wordt vermeld) dat u wel of niet kunt toewijzen aan welk doeltype (verticaal wordt vermeld). In de tabel betekent X toewijsbaar, een lege ruimte betekent niet toewijsbaar en ? alleen als de 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 ? ?

Gerelateerde inhoud

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