Tipi di dati in Bicep

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:

• array
• bool
• int
• object
• secureObject - indicato da Decorator in Bicep
• secureString : indicato da decorator in Bicep
• string

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 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 successiva.

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.

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 può 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 non è limitato, 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 le virgolette.

param exampleInt int = 1

In Bicep i numeri interi sono interi a 64 bit. Quando viene passato come parametri inline, l'intervallo di valori può essere limitato dallo strumento da 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 integer di grandi dimensioni in un file di parametri. I tipi di risorse applicano i propri limiti per le proprietà integer.

I formati a virgola mobile, decimale o binaria 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 da 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 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 per le 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, spazio, '-' o '.'. Nell'esempio seguente viene illustrato come usare l'interpolazione nelle chiavi delle 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

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 è 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ò essere diverso a seconda delle implementazioni. Ad esempio, la funzione Bicep items() ordina gli oggetti nell'ordine alfabetico. In altre posizioni, l'ordinamento originale può essere mantenuto. A causa di questo non determinismo, evitare di fare ipotesi sull'ordinamento delle chiavi oggetto durante la scrittura di codice, che interagisce con i parametri e gli output delle distribuzioni.

Quando si accede a una proprietà non existing 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. Sono consentiti tutti i caratteri Unicode con punti di codice compresi tra 0 e 10FFFF .

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 linea (LF)
\r	ritorno a capo (CR)
\t	carattere di tabulazioni
\u{x}	Punto di codice Unicode x	x rappresenta un valore punto di codice esadecimale compreso tra 0 e 10FFFF (inclusi entrambi). Sono consentiti zeri iniziali. I punti di codice sopra FFFF vengono generati come coppia di surrogati.
\$	$	Solo escape 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 nuova riga (la sequenza di apertura) e tre caratteri virgolette singole (''' - sequenza di chiusura). I caratteri immessi tra la sequenza di apertura e di chiusura vengono letti verbatim e non è necessario o possibile eseguire l'escape.

Nota

Poiché il parser Bicep legge tutti i caratteri così com'è, 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 a più righe. A causa di questa limitazione, potrebbe essere necessario usare la funzione anziché usare l'interpolazioneconcat.

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

Proteggere stringhe e oggetti

La stringa sicura usa lo stesso formato della stringa e l'oggetto protetto usa 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 e non viene registrato. Tuttavia, 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 viene 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 dei 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) o non può essere assegnato al tipo di destinazione (elencato verticalmente). Nella tabella X , significa assegnabile, spazio vuoto significa non assegnabile e ? significa solo se 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 di file Bicep.