Funzioni degli oggetti per Bicep
Questo articolo descrive le funzioni Bicep per operare con gli oggetti.
contains
contains(container, itemToFind)
Verifica se una matrice contiene un valore, se un oggetto contiene una chiave o se una stringa contiene una sottostringa. Il confronto fra stringhe fa distinzione tra maiuscole e minuscole. Tuttavia, quando si testa se un oggetto contiene una chiave, il confronto non fa distinzione tra maiuscole e minuscole.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| container | Sì | matrice, oggetto o stringa | Valore che contiene il valore da trovare. |
| itemToFind | Sì | stringa o numero intero | Valore da trovare. |
Valore restituito
True se l'elemento viene individuato; in caso contrario, restituisce False.
Esempio
L'esempio seguente illustra come usare contains con tipi diversi:
param stringToTest string = 'OneTwoThree'
param objectToTest object = {
one: 'a'
two: 'b'
three: 'c'
}
param arrayToTest array = [
'one'
'two'
'three'
]
output stringTrue bool = contains(stringToTest, 'e')
output stringFalse bool = contains(stringToTest, 'z')
output objectTrue bool = contains(objectToTest, 'one')
output objectFalse bool = contains(objectToTest, 'a')
output arrayTrue bool = contains(arrayToTest, 'three')
output arrayFalse bool = contains(arrayToTest, 'four')
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| stringTrue | Bool | Vero |
| stringFalse | Bool | Falso |
| objectTrue | Bool | Vero |
| objectFalse | Bool | Falso |
| arrayTrue | Bool | Vero |
| arrayFalse | Bool | Falso |
empty
empty(itemToTest)
Determina se una matrice, un oggetto o una stringa è vuota o null.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| itemToTest | Sì | matrice, oggetto o stringa | Valore da controllare se è vuoto o null. |
Valore restituito
Restituisce True se il valore è vuoto o null; in caso contrario, False.
Esempio
Nell'esempio seguente viene verificato se una matrice, un oggetto e una stringa sono vuoti o null.
param testArray array = []
param testObject object = {}
param testString string = ''
param testNullString string?
output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)
output stringNull bool = empty(testNullString)
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| arrayEmpty | Bool | Vero |
| objectEmpty | Bool | Vero |
| stringEmpty | Bool | Vero |
| stringNull | Bool | Vero |
intersection
intersection(arg1, arg2, arg3, ...)
Restituisce una matrice o un oggetto singoli con gli elementi comuni dei parametri.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| arg1 | Sì | matrice o oggetto | Primo valore da usare per cercare elementi comuni. |
| arg2 | Sì | matrice o oggetto | Secondo valore da usare per cercare elementi comuni. |
| argomenti aggiuntivi | No | matrice o oggetto | Valori aggiuntivi da usare per cercare elementi comuni. |
Valore restituito
Una matrice o un oggetto con elementi comuni.
Esempio
L'esempio seguente illustra come usare intersection con matrici e oggetti:
param firstObject object = {
one: 'a'
two: 'b'
three: 'c'
}
param secondObject object = {
one: 'a'
two: 'z'
three: 'c'
}
param firstArray array = [
'one'
'two'
'three'
]
param secondArray array = [
'two'
'three'
]
output objectOutput object = intersection(firstObject, secondObject)
output arrayOutput array = intersection(firstArray, secondArray)
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| objectOutput | Oggetto | {"one": "a", "three": "c"} |
| arrayOutput | Matrice | ["two", "three"] |
articoli
items(object)
Converte in matrice un oggetto dizionario. Vedere toObject per informazioni sulla conversione di una matrice in un oggetto.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| oggetto | Sì | oggetto | L’oggetto dizionario da convertire in matrice. |
Valore restituito
Matrice di oggetti per il dizionario convertito. Ogni oggetto nella matrice ha una proprietà key che contiene il valore della chiave per il dizionario. Ogni oggetto inoltre ha una proprietà value che contiene le proprietà per l'oggetto.
Esempio
Nell'esempio seguente un oggetto dizionario viene convertito in matrice. Per ciascun oggetto nella matrice, viene creato un nuovo oggetto con valori modificati.
var entities = {
item002: {
enabled: false
displayName: 'Example item 2'
number: 200
}
item001: {
enabled: true
displayName: 'Example item 1'
number: 300
}
}
var modifiedListOfEntities = [for entity in items(entities): {
key: entity.key
fullName: entity.value.displayName
itemEnabled: entity.value.enabled
}]
output modifiedResult array = modifiedListOfEntities
L'esempio precedente restituisce:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
L’esempio seguente mostra la matrice restituita dalla funzione elementi.
var entities = {
item002: {
enabled: false
displayName: 'Example item 2'
number: 200
}
item001: {
enabled: true
displayName: 'Example item 1'
number: 300
}
}
var entitiesArray = items(entities)
output itemsResult array = entitiesArray
L’esempio restituisce:
"itemsResult": {
"type": "Array",
"value": [
{
"key": "item001",
"value": {
"displayName": "Example item 1",
"enabled": true,
"number": 300
}
},
{
"key": "item002",
"value": {
"displayName": "Example item 2",
"enabled": false,
"number": 200
}
}
]
}
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'ordinamento delle chiavi oggetto durante la scrittura del codice, che interagisce con i parametri e gli output delle distribuzioni.
JSON
json(arg1)
Converte una stringa JSON valida in un tipo di dati JSON.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| arg1 | Sì | string | Valore da convertire in JSON. La stringa deve essere una stringa JSON formattata correttamente. |
Valore restituito
Il tipo di dati JSON dalla stringa specificata, o un valore vuoto quando viene specificato null.
Osservazioni:
Se è necessario includere un valore del parametro o una variabile nell'oggetto JSON, usare la funzione concat per creare la stringa che viene passata alla funzione.
Esempio
L'esempio seguente illustra come usare la funzione json. Si noti che è possibile passare null per un oggetto vuoto.
param jsonEmptyObject string = 'null'
param jsonObject string = '{\'a\': \'b\'}'
param jsonString string = '\'test\''
param jsonBoolean string = 'true'
param jsonInt string = '3'
param jsonArray string = '[[1,2,3]]'
param concatValue string = 'demo value'
output emptyObjectOutput bool = empty(json(jsonEmptyObject))
output objectOutput object = json(jsonObject)
output stringOutput string =json(jsonString)
output booleanOutput bool = json(jsonBoolean)
output intOutput int = json(jsonInt)
output arrayOutput array = json(jsonArray)
output concatObjectOutput object = json(concat('{"a": "', concatValue, '"}'))
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| emptyObjectOutput | Booleano | Vero |
| objectOutput | Oggetto | {"a": "b"} |
| stringOutput | String | test |
| booleanOutput | Booleano | Vero |
| intOutput | Intero | 3 |
| arrayOutput | Matrice | [ 1, 2, 3 ] |
| concatObjectOutput | Oggetto | {"a": "valore demo"} |
length
length(arg1)
Restituisce il numero di elementi in una matrice, caratteri in una stringa o proprietà a livello radice in un oggetto.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| arg1 | Sì | matrice, stringa o oggetto | La matrice da utilizzare per ottenere il numero di elementi, la stringa da utilizzare per ottenere il numero di caratteri o l'oggetto da utilizzare per ottenere il numero di proprietà a livello radice. |
Valore restituito
Numero intero
Esempio
L'esempio seguente illustra come usare length con una matrice e una stringa:
param arrayToTest array = [
'one'
'two'
'three'
]
param stringToTest string = 'One Two Three'
param objectToTest object = {
propA: 'one'
propB: 'two'
propC: 'three'
propD: {
'propD-1': 'sub'
'propD-2': 'sub'
}
}
output arrayLength int = length(arrayToTest)
output stringLength int = length(stringToTest)
output objectLength int = length(objectToTest)
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| arrayLength | Int | 3 |
| stringLength | Int | 13 |
| objectLength | Int | 4 |
objectKeys
objectKeys(object)
Restituisce le chiavi di un oggetto, in cui un oggetto è una raccolta di coppie chiave-valore.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| oggetto | Sì | oggetto | Oggetto , che è una raccolta di coppie chiave-valore. |
Valore restituito
Matrice .
Esempio
L'esempio seguente illustra come usare objectKeys con un oggetto :
var obj = { a: 1, b: 2 }
output keyArray array = objectKeys(obj)
L'output dell'esempio precedente è:
| Nome | Type | Valore |
|---|---|---|
| keyArray | Matrice | [ "a", "b" ] |
keyArray restituisce un elenco di chiavi dell'oggetto di input.
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.
shallowMerge
shallowMerge(inputArray)
Combina una matrice di oggetti, in cui vengono uniti solo gli oggetti di primo livello. Ciò significa che se gli oggetti uniti contengono oggetti annidati, tali oggetti annidati non vengono uniti in modo profondo. Vengono invece sostituiti interamente dalla proprietà corrispondente dall'oggetto di unione.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| inputArray | Sì | array | Matrice di oggetti . |
Valore restituito
Oggetto .
Esempio
Nell'esempio riportato di seguito viene illustrato come usare shallowMerge:
var firstArray = [{ one: 'a' }, { two: 'b' }, { two: 'c'}]
var secondArray = [{ one: 'a', nested: {a: 1, nested: {c: 3}} }, { two: 'b', nested: {b: 2}}]
output firstOutput object = shallowMerge(firstArray)
output secondOutput object = shallowMerge(secondArray)
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| firstOutput | oggetto | {"one":"a","two":"c"} |
| secondOutput | oggetto | {"one":"a","nested":{"b":2},"two":"b"} |
firstOutput mostra che le proprietà degli oggetti di unione vengono combinate in un nuovo oggetto. Se sono presenti proprietà in conflitto, ovvero proprietà con lo stesso nome, la proprietà dell'ultimo oggetto unito ha in genere la precedenza.
secondOutput mostra che l'unione superficiale non unisce in modo ricorsivo questi oggetti annidati. L'intero oggetto annidato viene invece sostituito dalla proprietà corrispondente dall'oggetto di unione.
union
union(arg1, arg2, arg3, ...)
Restituisce una matrice o un oggetto singoli con tutti gli elementi dei parametri. Per le matrici, i valori duplicati vengono inclusi una sola volta. Per gli oggetti, i nomi delle proprietà duplicati vengono inclusi una sola volta.
Spazio dei nomi: sys.
Parametri
| Parametro | Richiesto | Type | Descrizione |
|---|---|---|---|
| arg1 | Sì | matrice o oggetto | Primo valore da usare per l'aggiunta di elementi. |
| arg2 | Sì | matrice o oggetto | Secondo valore da usare per l'aggiunta di elementi. |
| argomenti aggiuntivi | No | matrice o oggetto | Valori aggiuntivi da usare per unire gli elementi. |
Valore restituito
Una matrice o un oggetto.
Osservazioni:
La funzione di unione usa la sequenza dei parametri per determinare l'ordine e i valori del risultato.
Per le matrici, la funzione itera attraverso ogni elemento nel primo parametro e lo aggiunge al risultato, se non è già presente. Ripete quindi il processo per il secondo parametro e qualsiasi altro parametro. Se un valore è già presente, la sua selezione host precedente nella matrice viene mantenuta.
Per gli oggetti, i nomi delle proprietà e i valori del primo parametro vengono aggiunti al risultato. Per i parametri successivi, tutti i nuovi nomi vengono aggiunti al risultato. Se un parametro successivo ha una proprietà con stesso nome, tale valore sovrascrive il valore esistente. L'ordine delle proprietà non è garantito.
La funzione di unione unisce non solo gli elementi di primo livello, ma unisce in modo ricorsivo anche tutti gli oggetti annidati all'interno di essi. I valori di matrice annidati non vengono uniti. Vedere il secondo esempio nella sezione seguente.
Esempio
L'esempio seguente illustra come usare union con matrici e oggetti:
param firstObject object = {
one: 'a'
two: 'b'
three: 'c1'
}
param secondObject object = {
three: 'c2'
four: 'd'
five: 'e'
}
param firstArray array = [
'one'
'two'
'three'
]
param secondArray array = [
'three'
'four'
'two'
]
output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)
L'output dell'esempio precedente con i valori predefiniti è il seguente:
| Nome | Type | Valore |
|---|---|---|
| objectOutput | Oggetto | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
| arrayOutput | Matrice | ["one", "two", "three", "four"] |
L'esempio seguente mostra la funzionalità deep merge:
var firstObject = {
property: {
one: 'a'
two: 'b'
three: 'c1'
}
nestedArray: [
1
2
]
}
var secondObject = {
property: {
three: 'c2'
four: 'd'
five: 'e'
}
nestedArray: [
3
4
]
}
var firstArray = [
[
'one'
'two'
]
[
'three'
]
]
var secondArray = [
[
'three'
]
[
'four'
'two'
]
]
output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)
L'output dell'esempio precedente è:
| Nome | Type | Valore |
|---|---|---|
| objectOutput | Oggetto | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]} |
| arrayOutput | Matrice | [["one","two"],["three"],["four","two"]] |
Se le matrici annidate sono state unite, il valore di objectOutput.nestedArray sarà [1, 2, 3, 4], e il valore di arrayOutput sarà [["one", "two", "three"], ["three", "four", "two"]].
Passaggi successivi
- Per una descrizione delle sezioni in un file Bicep, vedere Informazioni sulla struttura e la sintassi dei file Bicep.