Condividi tramite

Tipi di dati in Bicep

  • Articolo

Questo articolo descrive i tipi di dati supportati in Bicep. Per definire tipi di dati personalizzati, vedere Tipi di dati definiti dall'utente.

Matrici

Le matrici iniziano con una parentesi quadra sinistra ([) e terminano con una parentesi quadra destra (]). In Bicep è possibile dichiarare una matrice in una singola riga o in più righe. Le virgole (,) vengono usate tra i valori nelle dichiarazioni a riga singola, ma non vengono usate nelle dichiarazioni a più righe. È possibile combinare e associare dichiarazioni a riga singola e a più righe. La dichiarazione a più righe richiede l'interfaccia della riga di comando di Bicep versione 0.7.X o successiva.

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

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

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

Ogni elemento della matrice può essere di qualsiasi tipo. È possibile avere una matrice in cui ogni elemento è lo stesso tipo di dati o una matrice che contiene tipi di dati diversi.

Nell'esempio seguente viene illustrata una matrice di numeri interi e una matrice di tipi diversi.

var integerArray = [
  1
  2
  3
]

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

Le matrici in Bicep sono basate su zero. Nell'esempio seguente, l'espressione exampleArray[0] restituisce 1 e exampleArray[2] restituisce 3. L'indice dell'indicizzatore potrebbe essere un'altra espressione. L'espressione exampleArray[index] restituisce 2. Gli indicizzatori integer sono consentiti solo nell'espressione dei tipi di matrice.

var index = 1

var exampleArray = [
  1
  2
  3
]

Quando l'indice è fuori dai propri limiti, viene visualizzato l'errore seguente:

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

Per evitare questa eccezione, usare l'operatore logico Or, come illustrato nell'esempio seguente:

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
  • Usare gli operatori di confronto per confrontare due matrici.
  • Usare la funzione di accesso Index per ottenere un elemento da una matrice.
  • Usare l'operatore Safe-dereference per accedere agli elementi di una matrice.
  • Usare Spread per unire matrici.

Valori booleani

Quando si specificano valori booleani, usare true o false. Non racchiudere il valore tra virgolette.

param exampleBool bool = true

Vedere Funzione logica

Integer

Quando si specificano valori interi, non usare le virgolette.

param exampleInt int = 1

Gli interi bicep sono interi a 64 bit. Quando vengono passati come parametri inline, l'SDK o lo strumento da riga di comando usato per la distribuzione può limitare l'intervallo di valori. Ad esempio, quando si usa PowerShell per distribuire Bicep, i tipi integer possono variare da -2147483648 a 2147483647. Per evitare questa limitazione, specificare valori integer di grandi dimensioni in un file di parametri. I tipi di risorse applicano i propri limiti per le proprietà dei numeri interi.

Bicep supporta un tipo letterale integer che fa riferimento a un valore specifico che è un numero intero esatto. Nell'esempio seguente, 1 è un tipo letterale integer e foo può essere assegnato solo il valore 1 e nessun altro valore.

output foo 1 = 1

È possibile dichiarare un tipo letterale integer inline, come illustrato nell'esempio precedente o in un'istruzione type.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

Nell'esempio precedente, l'assegnazione 2 a restituisce un errore BCP033: "Previsto un valore di tipo ma il valore fornito è di tipo 1 2".bar

Nell'esempio seguente viene usato un tipo letterale integer con un tipo di unione:

output bar 1 | 2 | 3 = 3

I formati a virgola mobile, decimale o binaria non sono attualmente supportati.

Vedere Funzioni numeriche.

Oggetti

Gli oggetti iniziano con una parentesi graffa sinistra ({) e terminano con una parentesi graffa destra (}). In Bicep è possibile dichiarare un oggetto in una singola riga o in più righe. Ogni proprietà in un oggetto è costituita da una chiave e da un valore. La chiave e il valore sono separati dai due punti (:). Un oggetto consente qualsiasi proprietà di qualsiasi tipo. Le virgole (,) vengono usate tra le proprietà per le dichiarazioni a riga singola, ma non vengono usate tra le proprietà per le dichiarazioni a più righe. È possibile combinare e associare dichiarazioni a riga singola e a più righe. La dichiarazione a più righe richiede l'interfaccia della riga di comando di Bicep versione 0.7.X o successiva.

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 le virgolette sono facoltativamente consentite nelle chiavi delle proprietà dell'oggetto:

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

Nell'esempio precedente le virgolette vengono usate quando le chiavi delle proprietà dell'oggetto contengono caratteri speciali. Ad esempio, lo spazio, -o .. L’esempio seguente illustra come usare l'interpolazione nelle chiavi di proprietà dell'oggetto.

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

Le funzioni di accesso alle proprietà vengono utilizzate per accedere alle proprietà di un oggetto. Vengono costruiti usando l'operatore . .

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

È possibile usare funzioni di accesso alle proprietà con qualsiasi oggetto, inclusi parametri e variabili di tipi di oggetto e valori letterali oggetto. Una funzione di accesso alla proprietà utilizzata in un'espressione di un tipo non oggetto è un errore.

È anche possibile usare la sintassi [] per accedere a una proprietà. L'esempio seguente restituisce Development.

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

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

In JSON un oggetto è una raccolta non ordinata di zero o più coppie chiave o valore. L'ordinamento potrebbe essere diverso a seconda delle implementazioni. Ad esempio, la funzione Bicep items() ordina gli oggetti in ordine alfabetico. In altri luoghi, è possibile conservare l'ordinamento originale. A causa di questo non determinismo, evitare di fare ipotesi sull'ordinamento delle chiavi oggetto quando si scrive codice, che interagisce con i parametri e gli output di distribuzione.

Quando si accede a una proprietà non existing di un oggetto, viene visualizzato l'errore seguente:

The language expression property 'foo' doesn't exist

Per evitare l'eccezione, è possibile usare l'operatore logico And, come illustrato nell'esempio seguente:

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

output bar bool = contains(objectToTest, 'four') && objectToTest.four == 4
  • Utilizzare gli operatori di confronto per confrontare gli oggetti.
  • Utilizzare la funzione di accesso Index per ottenere una proprietà da un oggetto .
  • Usare l'operatore Safe-dereference per accedere ai membri dell'oggetto.
  • Usare Spread per unire gli oggetti.

Vedere Funzioni dell'oggetto.

Stringhe

In Bicep le stringhe sono contrassegnate con virgolette singole ed è necessario dichiararle su una singola riga. Tutti i caratteri Unicode con punti di codice compresi tra 0 e 10FFFF sono consentiti.

param exampleString string = 'test value'

La tabella seguente elenca il set di caratteri riservati di cui è necessario eseguire l'escape usando una barra rovesciata (\):

Sequenza di escape Valore rappresentato Note
\\ \
\' '
\n Avanzamento riga
\r Ritorno a capo
\t Carattere di tabulazioni
\u{x} Punto di codice Unicode x Rappresenta x un valore punto di codice esadecimale tra 0 e 10FFFF (inclusi entrambi). Sono consentiti zeri iniziali. I punti di codice precedenti FFFF vengono generati come coppia di surrogati.
\$ $ Eseguire l’escape solo se seguito da {. 
// evaluates to "what's up?"
var myVar = 'what\'s up?'

Bicep supporta un tipo letterale stringa che fa riferimento a un valore stringa specifico. Nell'esempio seguente è red un tipo letterale stringa. È possibile assegnare il valore red solo a redColor.

output redColor 'red' = 'red'

È possibile dichiarare un tipo letterale stringa inline, come illustrato nell'esempio precedente o in un'istruzione type.

type redColor = 'red'

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

Nell'esempio precedente, l'assegnazione blue a restituisce un errore BCP033: "Previsto un valore di tipo ma il valore fornito è di tipo red blue".colorBlue

L'esempio seguente mostra un tipo letterale stringa usato con un tipo di unione:

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

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

Tutte le stringhe in Bicep supportano l'interpolazione. Per inserire un'espressione, racchiuderla tra ${ e }. Le espressioni a cui viene fatto riferimento non possono estendersi su più righe.

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

Stringhe a più righe

In Bicep le stringhe a più righe sono definite tra tre virgolette singole (''') seguite facoltativamente da una nuova riga (la sequenza di apertura) e tre virgolette singole (''' è la sequenza di chiusura). I caratteri immessi tra la sequenza di apertura e di chiusura sono letti verbatim. L'escape non è necessario o possibile.

Nota

Il parser Bicep legge tutti i caratteri così come sono. A seconda delle terminazioni di riga del file Bicep, le nuove righe vengono interpretate come \r\n o \n.

L'interpolazione non è attualmente supportata nelle stringhe a più righe. A causa di questa limitazione, potrebbe essere necessario usare la concat funzione anziché usare l'interpolazione.

Le stringhe a più righe che contengono ''' non sono supportate.

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

Tipi unione

In Bicep, un tipo di unione consente la creazione di un tipo combinato costituito da un set di sottotipi. Un'assegnazione è valida se è consentita una delle singole assegnazioni di sottotipo. Il | carattere separa singoli sottotipi che usano una or condizione. Ad esempio, la sintassi a | b indica che un'assegnazione valida può essere a o b. I tipi di unione vengono convertiti nel vincolo allowed-value (valore consentito) in Bicep, quindi solo i valori letterali sono consentiti come membri. Le unioni possono includere un numero qualsiasi di espressioni di tipo letterale.

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

Le unioni dei tipi devono essere reducibili in un singolo tipo di Azure Resource Manager, ad esempio string, into bool. In caso contrario, viene visualizzato il codice di errore BCP294 . Ad esempio:

type foo = 'a' | 1

È possibile usare qualsiasi tipo di espressione come sottotipo in una dichiarazione di tipo unione (tra | caratteri). Ad esempio, tutti gli esempi seguenti sono validi:

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

Tipo di dati unione con tag personalizzati

Bicep supporta un tipo di dati unione con tag personalizzato, che rappresenta un valore che può essere uno dei diversi tipi. Per dichiarare un tipo di dati unione con tag personalizzati, è possibile usare un @discriminator() elemento Decorator. L'interfaccia della riga di comando di Bicep versione 0.21.X o successiva è necessaria per usare questo elemento Decorator. La sintassi è:

@discriminator('<property-name>')

L'elemento decorator discriminante accetta un singolo parametro, che rappresenta un nome di proprietà condiviso tra tutti i membri dell'unione. Questo nome di proprietà deve essere un valore letterale stringa obbligatorio per tutti i membri e fa distinzione tra maiuscole e minuscole. I valori della proprietà discriminata nei membri dell'unione devono essere univoci in modo che non fa distinzione tra maiuscole e minuscole.

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 }

Il valore del parametro viene convalidato in base al valore della proprietà discriminata. Ad esempio, nell'esempio precedente, se il serviceConfig parametro è di tipo foo, viene convalidato usando il FooConfig tipo . Analogamente, se il parametro è di tipo bar, viene convalidato usando il BarConfig tipo . Questo modello si applica anche ad altri tipi.

Il tipo di unione presenta alcune limitazioni:

  • I tipi di unione devono essere reducibili in un singolo tipo di Azure Resource Manager. La definizione seguente non è valida:

    type foo = 'a' | 1

  • Solo i valori letterali sono consentiti come membri.

  • Tutti i valori letterali devono essere dello stesso tipo di dati primitivo, ad esempio tutte le stringhe o tutti i numeri interi.

È possibile usare la sintassi del tipo di unione nei tipi di dati definiti dall'utente.

Stringhe e oggetti sicuri

Le stringhe protette usano lo stesso formato della stringa e gli oggetti sicuri usano lo stesso formato dell'oggetto. Con Bicep si aggiunge l'elemento @secure() Decorator a una stringa o a un oggetto .

Quando si imposta un parametro su una stringa sicura o un oggetto sicuro, il valore del parametro non viene salvato nella cronologia di distribuzione o registrato. Se si imposta tale valore sicuro su una proprietà che non prevede un valore sicuro, il valore non è protetto. Ad esempio, se si imposta una stringa sicura su un tag, tale valore verrà archiviato come testo normale. Usare stringhe sicure per password e segreti.

L'esempio seguente illustra due parametri sicuri:

@secure()
param password string

@secure()
param configValues object

Assegnazione di tipi di dati

In Bicep è possibile assegnare un valore di un tipo (tipo di origine) a un altro tipo (tipo di destinazione). La tabella seguente mostra il tipo di origine (elencato orizzontalmente) che è possibile assegnare o non è possibile assegnare al tipo di destinazione (elencato verticalmente). Nella tabella X significa assegnabile, uno spazio vuoto significa non assegnabile e ? significa solo se i tipi sono compatibili.

Tipi any error string number int bool null object array Risorsa denominata Modulo denominato 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 ?
Risorsa denominata X ? ?
Modulo denominato X ? ?

Passaggi successivi

Per informazioni sulla struttura e la sintassi di Bicep, vedere Struttura e sintassi dei file Bicep.