Funzioni degli oggetti per Bicep

  • Articolo

Questo articolo descrive le funzioni Bicep per l'uso degli 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 Obbligatorio 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 mostra come usare la funzione 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 sono vuoti.

Spazio dei nomi: sys.

Parametri

Parametro Obbligatorio Type Descrizione
itemToTest Sì matrice, oggetto o stringa Valore da controllare se è vuoto.

Valore restituito

True se il valore è vuoto; in caso contrario, restituisce False.

Esempio

L'esempio seguente controlla se una matrice, un oggetto e una stringa sono vuoti.

param testArray array = []
param testObject object = {}
param testString string = ''

output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome Type Valore
arrayEmpty Bool Vero
objectEmpty Bool Vero
stringEmpty 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 Obbligatorio 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 mostra come usare l'intersezione 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 Object {"one": "a", "three": "c"}
arrayOutput Matrice ["two", "three"]

articoli

items(object)

Converte un oggetto dizionario in una matrice. Vedere toObject sulla conversione di una matrice in un oggetto .

Spazio dei nomi: sys.

Parametri

Parametro Obbligatorio Type Descrizione
oggetto Sì oggetto Oggetto dizionario da convertire in una matrice.

Valore restituito

Matrice di oggetti per il dizionario convertito. Ogni oggetto nella matrice ha una key proprietà che contiene il valore della chiave per il dizionario. Ogni oggetto ha anche una value proprietà che contiene le proprietà per l'oggetto .

Esempio

Nell'esempio seguente un oggetto dizionario viene convertito in una matrice. Per ogni oggetto nella matrice, crea 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"
    }
  ]
}

Nell'esempio seguente viene illustrata la matrice restituita dalla funzione items.

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

JSON

json(arg1)

Converte una stringa JSON valida in un tipo di dati JSON.

Spazio dei nomi: sys.

Parametri

Parametro Obbligatorio Type Descrizione
arg1 Sì string Valore da convertire in JSON. La stringa deve essere una stringa JSON formattata correttamente.

Valore restituito

Tipo di dati JSON dalla stringa specificata o 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 Object {"a": "b"}
stringOutput String test
booleanOutput Booleano Vero
intOutput Intero 3
arrayOutput Matrice [ 1, 2, 3 ]
concatObjectOutput Object { "a": "demo value" }

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 Obbligatorio Type Descrizione
arg1 Sì matrice, stringa o oggetto Matrice da utilizzare per ottenere il numero di elementi, la stringa da utilizzare per ottenere il numero di caratteri o l'oggetto da usare per ottenere il numero di proprietà a livello radice.

Valore restituito

Numero intero

Esempio

L'esempio seguente mostra come usare la funzione 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

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 Obbligatorio 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 l'aggiunta di elementi.

Valore restituito

Una matrice o un oggetto.

Osservazioni:

La funzione union usa la sequenza dei parametri per determinare l'ordine e i valori del risultato.

Per le matrici, la funzione scorre ogni elemento nel primo parametro e lo aggiunge al risultato se non è già presente. Ripete quindi il processo per il secondo parametro ed eventuali parametri aggiuntivi. Se un valore è già presente, viene mantenuta la posizione precedente nella matrice.

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 lo 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 mostra come usare l'unione 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 Object {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput Matrice ["one", "two", "three", "four"]

L'esempio seguente illustra la funzionalità di merge avanzato:

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 Object {"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à [["uno", "two", "three", ["three", "four", "two"]].

Passaggi successivi