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.

Tipi supportati

All'interno di un Bicep, è possibile usare questi tipi di dati:

Matrici

Le matrici iniziano con una parentesi quadra sinistra ([) e terminano con una parentesi quadra destra (]). In Bicep, una matrice può essere dichiarata in una singola riga o in più righe. Le virgole (,) vengono utilizzate tra i valori nelle dichiarazioni a riga singola, ma sono non 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 successive.

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

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

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

In una matrice, ogni elemento è rappresentato da qualsiasi tipo. È possibile avere una matrice in cui ogni elemento è lo stesso tipo di dati o una matrice che contiene tipi di dati diversi.

L’esempio seguente mostra 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 di 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, è possibile 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

Valori booleani

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

param exampleBool bool = true

Integer

Quando si specificano valori interi, non usare virgolette.

param exampleInt int = 1

In Bicep, i numeri interi sono a 64 bit. Quando passato come parametri inline, l'intervallo di valori potrebbe essere limitato dallo strumento della riga di comando o dall'SDK usato per la distribuzione. Ad esempio, quando si usa PowerShell per distribuire un Bicep, i tipi integer possono variare da -2147483648 a 2147483647. Per evitare questa limitazione, specificare valori interi di grandi dimensioni in un file di parametri. I tipi di risorse applicano i propri limiti per le proprietà dei numeri interi.

I formati a virgola mobile, decimali o binari non sono attualmente supportati.

Oggetti

Gli oggetti iniziano con una parentesi graffa sinistra ({) e terminano con una parentesi graffa destra (}). In Bicep, un oggetto può essere dichiarato in una singola riga o in più righe. Ogni proprietà in un oggetto è costituita da chiave e valore. La chiave e il valore sono separati dai due punti (:). Un oggetto consente qualsiasi proprietà di qualsiasi tipo. Le virgole (,) vengono utilizzate tra le proprietà per le dichiarazioni a riga singola, ma non sono 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 successive.

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 per chiavi di proprietà di oggetti:

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, 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 costruite 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

Le funzioni di accesso alle proprietà possono essere usate con qualsiasi oggetto, inclusi parametri e variabili di tipi di oggetto e valori letterali oggetto. L'uso di una funzione di accesso alle proprietà in un'espressione di tipo non oggetto risulterà in 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/valore. L'ordinamento può variare, a seconda delle implementazioni. Ad esempio, la funzione Bicep items() dispone gli oggetti in ordine alfabetico. In altre posizioni, l'ordine originale può essere mantenuto. Dato questo non determinismo, è preferibile evitare di fare ipotesi sull'ordine delle chiavi oggetto durante la scrittura del codice, che interagisce con i parametri e gli output delle distribuzioni.

Quando si accede a una proprietà non esistente di un oggetto, verrà 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

Stringhe

In Bicep, le stringhe sono contrassegnate con virgolette singole e devono essere dichiarate 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 che devono essere preceduti da una barra rovesciata (\):

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

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 vengono definite tra tre virgolette singole (''') seguite facoltativamente da una newline (sequenza di apertura) e tre virgolette singole (''' - sequenza di chiusura). I caratteri immessi tra la sequenza di apertura e quella di chiusura vengono letti uno per uno, e non è necessario o possibile eseguire l'escape.

Nota

Poiché il parser Bicep legge tutti i caratteri così come sono, a seconda delle terminazioni di riga del file Bicep, le nuove righe possono essere interpretate come \r\n o \n.

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

Le stringhe a più righe contenenti ''' 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}'''

Stringhe e oggetti sicuri

La stringa sicura usa lo stesso formato delle stringhe e l'oggetto sicuro usa lo stesso formato degli oggetti. 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 su un oggetto sicuro, il valore del parametro non viene salvato nella cronologia di distribuzione e non viene registrato. Tuttavia, se si imposta tale valore sicuro su una proprietà che non prevede un valore sicuro, il valore non sarà 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 quali tipi di origine (elencati orizzontalmente) possano o non possano essere assegnati a quali tipi di destinazione (elencati verticalmente). Nella tabella, X significa assegnabile, spazio vuoto significa non assegnabile e ? significa solo se 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 di file Bicep.