Objektové funkce pro Bicep
Tento článek popisuje funkce Bicep pro práci s objekty.
obsahuje
contains(container, itemToFind)
Kontroluje, zda pole obsahuje hodnotu, objekt obsahuje klíč nebo řetězec obsahuje podřetězce. Porovnání řetězců se rozlišují malá a velká písmena. Při testování, pokud objekt obsahuje klíč, je však porovnání nerozlišující malá a velká písmena.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
kontejner | Ano | pole, objekt nebo řetězec | Hodnota, která obsahuje hodnotu, kterou chcete najít. |
itemToFind | Ano | řetězec nebo int | Hodnota, kterou chcete najít. |
Vrácená hodnota
Hodnota True , pokud je položka nalezena; v opačném případě false.
Příklad
Následující příklad ukazuje, jak používat obsahuje různé typy:
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')
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
stringTrue | Bool | True |
stringFalse | Bool | False |
objectTrue | Bool | True |
objectFalse | Bool | False |
arrayTrue | Bool | True |
arrayFalse | Bool | False |
empty
empty(itemToTest)
Určuje, zda je pole, objekt nebo řetězec prázdné.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
itemToTest | Ano | pole, objekt nebo řetězec | Hodnota, která se má zkontrolovat, jestli je prázdná. |
Vrácená hodnota
Vrátí hodnotu True , pokud je hodnota prázdná. V opačném případě vrátí hodnotu False.
Příklad
Následující příklad zkontroluje, zda pole, objekt a řetězec jsou prázdné.
param testArray array = []
param testObject object = {}
param testString string = ''
output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayEmpty | Bool | True |
objectEmpty | Bool | True |
stringEmpty | Bool | True |
Průsečíku
intersection(arg1, arg2, arg3, ...)
Vrátí jedno pole nebo objekt se společnými prvky z parametrů.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole nebo objekt | První hodnota, která se má použít k vyhledání společných prvků. |
arg2 | Ano | pole nebo objekt | Druhá hodnota, která se má použít k vyhledání společných prvků. |
další argumenty | No | pole nebo objekt | Další hodnoty, které se mají použít k vyhledání společných prvků. |
Vrácená hodnota
Pole nebo objekt se společnými prvky.
Příklad
Následující příklad ukazuje použití průniku s poli a objekty:
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)
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
objectOutput | Object | {"one": "a", "three": "c"} |
arrayOutput | Pole | ["two", "three"] |
položky
items(object)
Převede objekt slovníku na pole. Viz toObject o převodu pole na objekt.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
objekt | Ano | objekt | Objekt slovníku, který se má převést na pole. |
Vrácená hodnota
Pole objektů pro převedený slovník. Každý objekt v poli má key
vlastnost, která obsahuje hodnotu klíče pro slovník. Každý objekt má value
také vlastnost, která obsahuje vlastnosti objektu.
Příklad
Následující příklad převede objekt slovníku na pole. Pro každý objekt v poli vytvoří nový objekt s upravenými hodnotami.
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
Předchozí příklad vrátí:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
Následující příklad ukazuje pole, které je vráceno z funkce 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
Příklad vrátí:
"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
}
}
]
}
Ve formátu JSON je objekt neuspořádanou kolekcí párů klíč/hodnota nula nebo více. Řazení se může lišit v závislosti na implementacích. Například funkce Bicep items() seřadí objekty v abecedním pořadí. Na jiných místech lze původní řazení zachovat. Kvůli tomuto ne determinismu nepoužívejte žádné předpoklady týkající se řazení klíčů objektů při psaní kódu, které interaguje s parametry nasazení a výstupy.
json
json(arg1)
Převede platný řetězec JSON na datový typ JSON.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | string | Hodnota, která se má převést na JSON. Řetězec musí být správně naformátovaný řetězec JSON. |
Vrácená hodnota
Datový typ JSON ze zadaného řetězce nebo prázdná hodnota, pokud je zadána hodnota null .
Poznámky
Pokud potřebujete do objektu JSON zahrnout hodnotu parametru nebo proměnnou, pomocí funkce concat vytvořte řetězec, který funkci předáte.
Příklad
Následující příklad ukazuje, jak používat funkci JSON. Všimněte si, že pro prázdný objekt můžete předat hodnotu null .
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, '"}'))
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
emptyObjectOutput | Logická hodnota | True |
objectOutput | Object | {"a": "b"} |
stringOutput | String | test |
booleanOutput | Logická hodnota | True |
intOutput | Celé číslo | 3 |
arrayOutput | Pole | [ 1, 2, 3 ] |
concatObjectOutput | Object | { "a": "demo value" } |
length
length(arg1)
Vrátí počet prvků v poli, znaky v řetězci nebo vlastnosti kořenové úrovně v objektu.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole, řetězec nebo objekt | Pole, které se má použít pro získání počtu prvků, řetězec, který se má použít pro získání počtu znaků, nebo objekt, který se má použít pro získání počtu vlastností kořenové úrovně. |
Vrácená hodnota
Int.
Příklad
Následující příklad ukazuje, jak použít délku s polem a řetězcem:
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)
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayLength | Int | 3 |
stringLength | Int | 13 |
objectLength | Int | 4 |
sjednocení
union(arg1, arg2, arg3, ...)
Vrátí jednu matici nebo objekt se všemi prvky z parametrů. U polí se duplicitní hodnoty zahrnou jednou. U objektů jsou duplicitní názvy vlastností zahrnuty pouze jednou.
Obor názvů: sys.
Parametry
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole nebo objekt | První hodnota, která se má použít pro spojování prvků. |
arg2 | Ano | pole nebo objekt | Druhá hodnota, která se má použít pro spojování prvků. |
další argumenty | No | pole nebo objekt | Další hodnoty, které se mají použít pro spojování prvků. |
Vrácená hodnota
Pole nebo objekt.
Poznámky
Funkce sjednocení používá posloupnost parametrů k určení pořadí a hodnot výsledku.
U polí funkce iteruje každý prvek v prvním parametru a přidá ji do výsledku, pokud ještě není k dispozici. Potom tento proces zopakuje pro druhý parametr a všechny další parametry. Pokud je hodnota již přítomna, je dřívější umístění v poli zachováno.
Pro objekty se do výsledku přidají názvy vlastností a hodnoty z prvního parametru. Pro pozdější parametry se do výsledku přidají všechny nové názvy. Pokud má pozdější parametr vlastnost se stejným názvem, tato hodnota přepíše existující hodnotu. Pořadí vlastností není zaručeno.
Sjednocovací funkce slučuje nejen prvky nejvyšší úrovně, ale také rekurzivně slučuje všechny vnořené objekty v nich. Vnořené hodnoty pole nejsou sloučeny. Podívejte se na druhý příklad v následující části.
Příklad
Následující příklad ukazuje použití sjednocení s poli a objekty:
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)
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
objectOutput | Object | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
arrayOutput | Pole | ["one", "two", "three", "four"] |
Následující příklad ukazuje možnosti hloubkového sloučení:
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)
Výstup z předchozího příkladu je:
Name | Typ | Hodnota |
---|---|---|
objectOutput | Object | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3;4]} |
arrayOutput | Pole | [["one";"two"],["three"],["four";"two"]] |
Pokud byly vnořené matice sloučeny, hodnota objectOutput.nestedArray by byla [1, 2, 3, 4] a hodnota arrayOutput by byla [["jedna", "two", "three"], ["three", "four", "two"]].
Další kroky
- Popis oddílů v souboru Bicep najdete v tématu Vysvětlení struktury a syntaxe souborů Bicep.