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ò variare, a seconda delle implementazioni. Ad esempio, la funzione elementi() Bicep dispone gli oggetti in ordine alfabetico. In altre posizioni, l'ordinamento di origine può essere mantenuto. Dato questo non determinismo, è preferibile evitare di fare ipotesi sull'ordinamento 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 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 multilinea
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 multilinea. 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}'''
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 è 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.
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per