Datatyper i Bicep

Artikel
08/20/2024

Den här artikeln beskriver de datatyper som stöds i Bicep. Information om hur du definierar anpassade datatyper finns i Användardefinierade datatyper.

Typer som stöds

I en Bicep kan du använda följande datatyper:

samling
Bool
Int
objekt
secureObject – indikeras av dekoratör i Bicep
secureString – indikeras av dekoratör i Bicep
sträng

Matriser

Matriser börjar med en vänster hakparentes ([) och slutar med en höger hakparentes (]). I Bicep kan en matris deklareras på en rad eller flera rader. Kommatecken (,) används mellan värden i enradsdeklarationer, men används inte i deklarationer med flera rader. Du kan blanda och matcha deklarationer med en rad och flera rader. Deklarationen med flera rader kräver Bicep CLI version 0.7.X eller senare.

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

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

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

Varje matriselement kan vara av vilken typ som helst. Du kan ha en matris där varje objekt är samma datatyp eller en matris som innehåller olika datatyper.

I följande exempel visas en matris med heltal och en matris av olika typer.

var integerArray = [
  1
  2
  3
]

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

Matriser i Bicep är nollbaserade. I följande exempel utvärderas uttrycket exampleArray[0] till 1 och exampleArray[2] utvärderas till 3. Indexerarens index kan vara ett annat uttryck. Uttrycket exampleArray[index] utvärderas till 2. Heltalsindexerare tillåts endast för uttryck av matristyper.

var index = 1

var exampleArray = [
  1
  2
  3
]

Du får följande fel när indexet ligger utanför gränserna:

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

För att undvika det här undantaget kan du använda operatorn Eller logisk som du ser i följande exempel:

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

Booleska värden

När du anger booleska värden använder du true eller false. Omge inte värdet med citattecken.

param exampleBool bool = true

Heltal

Använd inte citattecken när du anger heltalsvärden.

param exampleInt int = 1

Bicep-heltal är 64-bitars heltal. När de skickas som infogade parametrar kan intervallet med värden begränsas av det SDK eller kommandoradsverktyg som du använder för distribution. När du till exempel använder PowerShell för att distribuera en Bicep kan heltalstyper variera från -2147483648 till 2147483647. För att undvika den här begränsningen anger du stora heltalsvärden i en parameterfil. Resurstyper tillämpar sina egna gränser för heltalsegenskaper.

Bicep stöder heltalsliteraltyp som refererar till ett specifikt värde som är ett exakt heltal. I följande exempel är 1 en heltalsliteraltyp, foo kan bara tilldelas värdet 1 och inget annat värde.

output foo 1 = 1

En heltalsliteraltyp kan antingen deklareras infogad, som du ser i föregående exempel, eller i en type -instruktion.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

I föregående exempel resulterar tilldelningen av 2 till stapeln i ett BCP033-fel – Förväntade ett värde av typen "1" men det angivna värdet är av typen "2".

I följande exempel visas hur du använder heltalsliteraltyp med uniontyp:

output bar 1 | 2 | 3 = 3

Flyttal, decimal- eller binärformat stöds inte för närvarande.

Objekt

Objekt börjar med en vänster klammerparentes ({) och slutar med en höger klammerparentes (}). I Bicep kan ett objekt deklareras på en rad eller flera rader. Varje egenskap i ett objekt består av nyckel och värde. Nyckeln och värdet avgränsas med ett kolon (:). Ett objekt tillåter alla egenskaper av vilken typ som helst. Kommatecken (,) används mellan egenskaper för enradsdeklarationer, men används inte mellan egenskaper för deklarationer med flera rader. Du kan blanda och matcha deklarationer med en rad och flera rader. Deklarationen med flera rader kräver Bicep CLI version 0.7.X eller senare.

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}

I Bicep tillåts citattecken på objektegenskapsnycklar:

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

I föregående exempel används citattecken när objektegenskapsnycklarna innehåller specialtecken. Till exempel blanksteg, "-" eller ".". I följande exempel visas hur du använder interpolering i objektegenskapsnycklar.

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

Egenskapsåtkomster används för att komma åt egenskaper för ett objekt. De konstrueras med operatorn . .

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

Egenskapsåtkomster kan användas med valfritt objekt, inklusive parametrar och variabler för objekttyper och objektliteraler. Ett fel är att använda en egenskapsåtkomstor för ett uttryck av typen icke-objekt.

Du kan också använda syntaxen [] för att komma åt en egenskap. I följande exempel returneras Development.

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

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

I JSON är ett objekt en osorterad samling med noll eller fler nyckel/värde-par. Beställningen kan variera beroende på implementeringarna. Funktionen Bicep items() sorterar till exempel objekten i alfabetisk ordning. På andra ställen kan den ursprungliga ordningen bevaras. På grund av denna icke-determinism bör du undvika att göra några antaganden om ordningen på objektnycklar när du skriver kod, som interagerar med distributionsparametrar och utdata.

Du får följande fel när du kommer åt en icke-existerande egenskap för ett objekt:

The language expression property 'foo' doesn't exist

För att undvika undantaget kan du använda den logiska operatorn Och enligt följande exempel:

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

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

Strängar

I Bicep markeras strängar med enkla citattecken och måste deklareras på en enda rad. Alla Unicode-tecken med kodpunkter mellan 0 och 10FFFF tillåts.

param exampleString string = 'test value'

I följande tabell visas den uppsättning reserverade tecken som måste kringgås av ett omvänt snedstreck (\) tecken:

Escape-sekvens	Representerat värde	Kommentar
`\\`	`\`
`\'`	`'`
`\n`	linjematning (LF)
`\r`	vagnretur (CR)
`\t`	tabbtecken
`\u{x}`	Unicode-kodpunkt `x`	x representerar ett hexadecimalt kodpunktsvärde mellan 0 och 10FFFF (båda inkluderande). Inledande nollor tillåts. Kodpunkter ovanför FFFF genereras som ett surrogatpar.
`\$`	`$`	Undvik endast när följt av `{`.

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

Bicep stöder strängliteraltyp som refererar till ett specifikt strängvärde. I följande exempel är rött en strängliteral typ, redColor kan bara tilldelas värdet rött och inget annat värde.

output redColor 'red' = 'red'

En strängliteraltyp kan antingen deklareras infogad, som du ser i föregående exempel, eller i en type instruktion.

type redColor = 'red'

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

I föregående exempel resulterar tilldelning av blått till colorBlue i ett BCP033-fel – Förväntade ett värde av typen "'red'" men det angivna värdet är av typen "'blue'".

I följande exempel visas hur du använder strängliteraltyp med unionstyp:

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

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

Alla strängar i Bicep stöder interpolering. Om du vill mata in ett uttryck omger du det med ${ och }. Uttryck som refereras kan inte sträcka sig över flera rader.

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

Flerradssträngar

I Bicep definieras flerradssträngar mellan tre enkla citattecken (''') följt av en ny rad (öppningssekvensen) och tre enkla citattecken (''' - den avslutande sekvensen). Tecken som anges mellan öppnings- och avslutningssekvensen läss ordagrant och ingen undflyende är nödvändig eller möjlig.

Kommentar

Eftersom Bicep-parsern läser alla tecken som är, beroende på radsluten för din Bicep-fil, kan nya rader tolkas som antingen \r\n eller \n.

Interpolering stöds för närvarande inte i flerradssträngar. På grund av den här begränsningen concat kan du behöva använda funktionen i stället för att använda interpolering.

Flerradssträngar som innehåller ''' stöds inte.

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

Union-typer

I Bicep tillåter en union typ att skapa en kombinerad typ som består av en uppsättning undertyper. En tilldelning är giltig om någon av de enskilda undertyptilldelningarna tillåts. Tecknet | separerar enskilda undertyper med hjälp av ett eller villkor. Till exempel syntaxen "a" | "b" innebär att en giltig tilldelning kan vara antingen "a" eller "b". Union-typer översätts till villkoret allowed-value i Bicep, så endast literaler tillåts som medlemmar. Unioner kan innehålla valfritt antal literaltypade uttryck.

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

Typfack måste kunna återskapas till en enda ARM-typ, till exempel "string", "int" eller "bool". Annars får du BCP294-felkoden . Till exempel:

type foo = 'a' | 1

Alla typuttryck kan användas som en undertyp i en unionstypdeklaration (mellan | tecken). Följande exempel är till exempel giltiga:

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

Anpassad taggad union-datatyp

Bicep stöder anpassad taggad union-datatyp, som används för att representera ett värde som kan vara en av flera olika typer. Om du vill deklarera en anpassad taggad union-datatyp kan du använda en @discriminator() dekoratör. Bicep CLI version 0.21.X eller senare krävs för att använda den här dekoratören. Syntax:

@discriminator('<property-name>')

Den diskriminerande dekoratören tar en enda parameter, som representerar ett delat egenskapsnamn bland alla fackföreningsmedlemmar. Det här egenskapsnamnet måste vara en obligatorisk strängliteral för alla medlemmar och är skiftlägeskänslig. Värdena för den diskriminerade egendomen på fackföreningsmedlemmarna måste vara unika på ett skiftlägesokänsligt sätt.

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 }

Parametervärdet verifieras baserat på det diskriminerade egenskapsvärdet. Om parametern serviceConfig till exempel i föregående exempel är av typen foo verifieras den med fooConfig-typen. Om parametern är av typen bar verifieras den på samma sätt med hjälp av BarConfig-typen . Det här mönstret gäller även för andra typer.

Det finns vissa begränsningar med unionstyp.

Union-typer måste kunna återskapas till en enda ARM-typ (Azure Resource Manager). Följande definition är ogiltig:
```
type foo = 'a' | 1
```
Endast literaler tillåts som medlemmar.
Alla literaler måste ha samma primitiva datatyp (till exempel alla strängar eller alla heltal).

Syntaxen för unionstyp kan användas i användardefinierade datatyper.

Skydda strängar och objekt

Säker sträng använder samma format som sträng, och skyddat objekt använder samma format som objektet. Med Bicep lägger du till dekoratören i @secure() en sträng eller ett objekt.

När du anger en parameter till en säker sträng eller ett säkert objekt sparas inte värdet för parametern i distributionshistoriken och loggas inte. Men om du ställer in det säkra värdet på en egenskap som inte förväntar sig ett säkert värde skyddas inte värdet. Om du till exempel anger en säker sträng till en tagg lagras det värdet som oformaterad text. Använd säkra strängar för lösenord och hemligheter.

I följande exempel visas två säkra parametrar:

@secure()
param password string

@secure()
param configValues object

Tilldelning av datatyp

I Bicep kan ett värde av en typ (källtyp) tilldelas till en annan typ (måltyp). I följande tabell visas vilken källtyp (visas vågrätt) som kan eller inte kan tilldelas till vilken måltyp (visas lodrätt). I tabellen X innebär tilldelningsbart, tomt utrymme inte kan tilldelas, och ? innebär endast om de typerna är kompatibla.

Typer	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	namngiven resurs	namngiven 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`											?
namngiven resurs	X						?		?
namngiven modul	X						?			?

Nästa steg

Mer information om strukturen och syntaxen för Bicep finns i Bicep-filstrukturen.

Dela via