Dela via

Datatyper i Bicep

  • Artikel

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

Matriser

Matriser börjar med en vänster hakparentes ([) och slutar med en höger hakparentes (]). I Bicep kan du deklarera en matris på en enda rad eller på flera rader. Kommatecken (,) används mellan värden i enradsdeklarationer, men de 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 med olika typer.

var integerArray = [
  1
  2
  3
]

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

Matriser i Bicep baseras på noll. 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 uttrycket för 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

Undvik det här undantaget genom att 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

Se Logisk funktion

Heltal

När du anger heltalsvärden ska du inte använda citattecken.

param exampleInt int = 1

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

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

output foo 1 = 1

Du kan deklarera en heltalsliteraltyp antingen 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 till ett BCP033-fel: "Förväntade ett värde av typen 1 men det angivna värdet är av typen 2."bar 2

I följande exempel används en heltalsliteraltyp med en unionstyp:

output bar 1 | 2 | 3 = 3

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

Se Numeriska funktioner.

Objekt

Objekt börjar med en vänster klammerparentes ({) och slutar med en höger klammerparentes (}). I Bicep kan du deklarera ett objekt på en enda rad eller på flera rader. Varje egenskap i ett objekt består av en nyckel och ett 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 enkelradsdeklarationer, men de 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. Exempel är 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 skapas med hjälp av 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

Du kan använda egenskapsåtkomster med valfritt objekt, inklusive parametrar och variabler för objekttyper och objektliteraler. En egenskapsåtkomstor som används i ett uttryck av en icke-objekttyp är ett fel.

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- eller värdepar. Ordningen kan variera beroende på implementeringarna. Funktionen Bicep items() sorterar till exempel objekten i alfabetisk ordning. På andra ställen kan du bevara den ursprungliga ordningen. På grund av denna nondeterminism 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 operatorn Och logisk, som du ser i följande exempel:

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

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

Se Objektfunktioner.

Strängar

I Bicep markeras strängar med enkla citattecken och du måste deklarera dem 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 du måste ta bort med hjälp 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åde inkluderande). Inledande nollor tillåts. Kodpunkterna ovan 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 en strängliteraltyp som refererar till ett specifikt strängvärde. I följande exempel red är en strängliteral typ. Du kan bara tilldela värdet red till redColor.

output redColor 'red' = 'red'

Du kan deklarera en strängliteraltyp antingen 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 tilldelningen till ett BCP033-fel: "Förväntade ett värde av typen red men det angivna värdet är av typen blue."colorBlue blue

I följande exempel visas en strängliteraltyp som används med en 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 (''' är den avslutande sekvensen). Tecken som anges mellan öppnings- och avslutningssekvensen läss ordagrant. Det är inte nödvändigt eller möjligt att fly.

Kommentar

Bicep-parsern läser alla tecken som de är. Beroende på radsluten för din Bicep-fil tolkas nya rader 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 som använder ett or villkor. Syntaxen a | b innebär till exempel 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 Azure Resource Manager-typ, till exempel string, inteller bool. Annars får du BCP294-felkoden . Till exempel:

type foo = 'a' | 1

Du kan använda valfritt typuttryck 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 en anpassad taggad union-datatyp som används för att representera ett värde som kan vara en av flera 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 till exempel är av typen fooi föregående exempel verifieras den serviceConfig med hjälp FooConfig av typen . Om parametern är av typen barvalideras den på samma sätt med hjälp BarConfig av typen . Det här mönstret gäller även för andra typer.

Union-typen har vissa begränsningar:

  • Union-typer måste kunna återskapas till en enda Azure Resource Manager-typ. 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).

Du kan använda syntaxen för unionstyp 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. 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 du tilldela ett värde av en typ (källtyp) till en annan typ (måltyp). I följande tabell visas vilken källtyp (visas vågrätt) som du kan eller inte kan tilldela till vilken måltyp (visas lodrätt). I tabellen betyder X tilldelningsbar, ett tomt utrymme innebär att det inte går att tilldela, och ? innebär bara om typerna är kompatibla.

Typer any error 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 ? ?

Relaterat innehåll

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