A Bicep objektumfüggvényei

  • Cikk

Ez a cikk az objektumok használatához használható Bicep-függvényeket ismerteti.

contains

contains(container, itemToFind)

Ellenőrzi, hogy egy tömb tartalmaz-e értéket, egy objektum tartalmaz-e kulcsot, vagy egy sztring tartalmaz-e részsztringet. A sztringek összehasonlítása megkülönbözteti a kis- és nagybetűk értékét. Ha azonban egy objektum tartalmaz kulcsot, az összehasonlítás érzéketlen.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
tároló Igen tömb, objektum vagy sztring A keresendő értéket tartalmazó érték.
itemToFind Igen sztring vagy int A keresendő érték.

Visszaadott érték

Igaz , ha az elem megtalálható; ellenkező esetben Hamis.

Példa

Az alábbi példa bemutatja, hogyan használható különböző típusú:

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

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
stringTrue Bool Igaz
stringFalse Bool Hamis
objectTrue Bool Igaz
objectFalse Bool Hamis
arrayTrue Bool Igaz
arrayFalse Bool Hamis

üres

empty(itemToTest)

Meghatározza, hogy egy tömb, objektum vagy sztring üres-e.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
itemToTest Igen tömb, objektum vagy sztring Az az érték, amely ellenőrzi, hogy üres-e.

Visszaadott érték

Igaz értéket ad vissza, ha az érték üres; ellenkező esetben Hamis.

Példa

Az alábbi példa azt ellenőrzi, hogy egy tömb, objektum és sztring üres-e.

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

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

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
arrayEmpty Bool Igaz
objectEmpty Bool Igaz
stringEmpty Bool Igaz

Kereszteződés

intersection(arg1, arg2, arg3, ...)

Egyetlen tömböt vagy objektumot ad vissza a paraméterek gyakori elemeivel.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
arg1 Igen tömb vagy objektum A gyakori elemek megkereséséhez elsőként használandó érték.
arg2 Igen tömb vagy objektum A második érték, amelyet a gyakori elemek kereséséhez használunk.
további argumentumok Nem tömb vagy objektum További értékek, amelyek a gyakori elemek kereséséhez használhatók.

Visszaadott érték

Egy tömb vagy objektum a közös elemekkel.

Példa

Az alábbi példa bemutatja, hogyan használható metszet tömbökkel és objektumokkal:

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)

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
objectOutput Objektum {"one": "a", "három": "c"}
arrayOutput Tömb ["two", "three"]

elem

items(object)

Egy szótárobjektumot tömbté alakít át. Tekintse meg a tömb objektummá alakításáról szóló toObject című témakört.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
object Igen object A tömbké konvertálandó szótárobjektum.

Visszaadott érték

A konvertált szótár objektumtömbje. A tömb minden objektuma rendelkezik egy key tulajdonságmal, amely tartalmazza a szótár kulcsértékét. Minden objektum rendelkezik egy value tulajdonsággal is, amely az objektum tulajdonságait tartalmazza.

Példa

Az alábbi példa egy szótárobjektumot tömbté alakít át. A tömb minden objektumához létrehoz egy új objektumot módosított értékekkel.

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

Az előző példa a következőt adja vissza:

"modifiedResult": {
  "type": "Array",
  "value": [
    {
      "fullName": "Example item 1",
      "itemEnabled": true,
      "key": "item001"
    },
    {
      "fullName": "Example item 2",
      "itemEnabled": false,
      "key": "item002"
    }
  ]
}

Az alábbi példa az elemek függvényből visszaadott tömböt mutatja be.

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

A példa a következőt adja vissza:

"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
      }
    }
  ]
}

A JSON-ban az objektum nulla vagy több kulcs/érték pár rendezetlen gyűjteménye. A rendezés a megvalósítástól függően eltérő lehet. A Bicep items() függvény például betűrendbe rendezi az objektumokat. Más helyeken az eredeti sorrend megőrizhető. Emiatt a nem determinizmus miatt ne feltételezze az objektumkulcsok sorrendjét a kód írásakor, amely az üzembehelyezési paraméterekkel és kimenetekkel kommunikál.

json

json(arg1)

Egy érvényes JSON-sztringet JSON-adattípussá alakít át.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
arg1 Igen húr A JSON-ra konvertálandó érték. A sztringnek megfelelően formázott JSON-sztringnek kell lennie.

Visszaadott érték

A megadott sztring JSON-adattípusa, vagy null érték megadásakor üres érték.

Megjegyzések

Ha paraméterértéket vagy változót kell megadnia a JSON-objektumban, az összefűző függvénnyel hozza létre a függvénynek átadott sztringet .

Példa

Az alábbi példa a json függvény használatát mutatja be. Figyelje meg, hogy üres objektum esetén null értéket adhat meg.

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, '"}'))

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
emptyObjectOutput Logikai Igaz
objectOutput Objektum {"a": "b"}
stringOutput Sztring teszt
booleanOutput Logikai Igaz
intOutput Egész 3
arrayOutput Tömb [ 1, 2, 3 ]
concatObjectOutput Objektum { "a": "demo value" }

length (hossz)

length(arg1)

Egy tömb elemeinek számát, egy sztringben szereplő karaktereket vagy egy objektum gyökérszintű tulajdonságait adja vissza.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
arg1 Igen tömb, sztring vagy objektum Az elemek számának lekéréséhez használandó tömb, a karakterek számának lekéréséhez használandó sztring vagy a gyökérszintű tulajdonságok számának lekéréséhez használni kívánt objektum.

Visszaadott érték

Egy int.

Példa

Az alábbi példa a hossz tömbökkel és sztringekkel való használatát mutatja be:

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)

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
arrayLength Int 3
stringLength Int 13
objectLength Int 4

unió

union(arg1, arg2, arg3, ...)

Egyetlen tömböt vagy objektumot ad vissza a paraméterek összes elemével. Tömbök esetén a rendszer egyszer tartalmazza az ismétlődő értékeket. Objektumok esetén a rendszer csak egyszer tartalmazza a duplikált tulajdonságneveket.

Névtér: sys.

Paraméterek

Paraméter Szükséges Típus Leírás
arg1 Igen tömb vagy objektum Az első elemillesztéshez használható érték.
arg2 Igen tömb vagy objektum Az elemek összekapcsolásához használt második érték.
további argumentumok Nem tömb vagy objektum További értékek az elemek összekapcsolásához.

Visszaadott érték

Tömb vagy objektum.

Megjegyzések

Az egyesítő függvény a paraméterek sorrendjét használja az eredmény sorrendjének és értékeinek meghatározásához.

Tömbök esetén a függvény végigfut az első paraméter minden elemén, és hozzáadja az eredményhez, ha még nincs jelen. Ezután megismétli a második paraméter és a további paraméterek folyamatát. Ha egy érték már jelen van, a tömb korábbi elhelyezése megmarad.

Objektumok esetén a rendszer hozzáadja az első paraméter tulajdonságneveit és értékeit az eredményhez. A későbbi paraméterek esetében a rendszer minden új nevet hozzáad az eredményhez. Ha egy későbbi paraméter azonos nevű tulajdonsággal rendelkezik, az az érték felülírja a meglévő értéket. A tulajdonságok sorrendje nem garantált.

Az egyesítő függvény nem csak a legfelső szintű elemeket egyesíti, hanem rekurzív módon egyesíti a bennük lévő beágyazott objektumokat is. A beágyazott tömbértékek nincsenek egyesítve. Lásd a második példát a következő szakaszban.

Példa

Az alábbi példa azt mutatja be, hogyan használható az unió tömbökkel és objektumokkal:

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)

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
objectOutput Objektum {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput Tömb ["egy", "kettő", "három", "négy"]

Az alábbi példa a mélyegyesítési képességet mutatja be:

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)

Az előző példa kimenete a következő:

Név Típus Érték
objectOutput Objektum {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput Tömb [["egy","két"],["három"],["négy","kettő"]]

Ha a beágyazott tömbök egyesítve lennének, akkor az objectOutput.nestedArray értéke [1, 2, 3, 4], a arrayOutput értéke pedig [["one", "two", "three"], ["three", "four", "two"]].

Következő lépések