Share via

Funkcje obiektów dla Bicep

  • Artykuł

W tym artykule opisano funkcje Bicep do pracy z obiektami.

zawiera

contains(container, itemToFind)

Sprawdza, czy tablica zawiera wartość, obiekt zawiera klucz, czy ciąg zawiera podciąg. Porównanie ciągów uwzględnia wielkość liter. Jednak podczas testowania, czy obiekt zawiera klucz, porównanie jest bez uwzględniania wielkości liter.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
kontener Tak tablica, obiekt lub ciąg Wartość zawierająca wartość do znalezienia.
itemToFind Tak ciąg lub int Wartość do znalezienia.

Wartość zwracana

Wartość True , jeśli element zostanie znaleziony; w przeciwnym razie wartość False.

Przykład

W poniższym przykładzie pokazano, jak używać elementów z różnymi typami:

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

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
stringTrue Bool Prawda
stringFalse Bool Fałsz
objectTrue Bool Prawda
objectFalse Bool Fałsz
arrayTrue Bool Prawda
arrayFalse Bool Fałsz

empty

empty(itemToTest)

Określa, czy tablica, obiekt lub ciąg jest pusta.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
itemToTest Tak tablica, obiekt lub ciąg Wartość do sprawdzenia, czy jest pusta.

Wartość zwracana

Zwraca wartość True , jeśli wartość jest pusta; w przeciwnym razie wartość False.

Przykład

Poniższy przykład sprawdza, czy tablica, obiekt i ciąg są puste.

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

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

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
arrayEmpty Bool Prawda
objectEmpty Bool Prawda
stringEmpty Bool Prawda

Przecięcia

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

Zwraca pojedynczą tablicę lub obiekt ze wspólnymi elementami z parametrów.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
arg1 Tak tablica lub obiekt Pierwsza wartość używana do znajdowania typowych elementów.
arg2 Tak tablica lub obiekt Druga wartość używana do znajdowania typowych elementów.
argumenty dodatkowe Nie. tablica lub obiekt Dodatkowe wartości do użycia do znajdowania typowych elementów.

Wartość zwracana

Tablica lub obiekt ze wspólnymi elementami.

Przykład

W poniższym przykładzie pokazano, jak używać przecięcia z tablicami i obiektami:

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)

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
objectOutput Objekt {"one": "a", "trzy": "c"}
arrayOutput Tablica ["dwa", "trzy"]

elementy

items(object)

Konwertuje obiekt słownika na tablicę. Zobacz obiekt toObject dotyczący konwertowania tablicy na obiekt.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
obiekt Tak obiekt Obiekt słownika do konwersji na tablicę.

Wartość zwracana

Tablica obiektów dla przekonwertowanego słownika. Każdy obiekt w tablicy ma właściwość zawierającą key wartość klucza słownika. Każdy obiekt ma również właściwość zawierającą value właściwości obiektu.

Przykład

Poniższy przykład konwertuje obiekt słownika na tablicę. Dla każdego obiektu w tablicy tworzy nowy obiekt z zmodyfikowanymi wartościami.

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

Powyższy przykład zwraca następujące dane:

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

W poniższym przykładzie pokazano tablicę zwracaną z funkcji 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

Przykład zwraca następujące dane:

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

W formacie JSON obiekt jest nieurządkowaną kolekcją par klucz/wartość zero lub więcej. Kolejność może być różna w zależności od implementacji. Na przykład funkcja Bicep items() sortuje obiekty w kolejności alfabetycznej. W innych miejscach można zachować oryginalną kolejność. Ze względu na ten niedeterminizm należy unikać wprowadzania wszelkich założeń dotyczących porządkowania kluczy obiektów podczas pisania kodu, który wchodzi w interakcje z parametrami i danymi wyjściowymi wdrożeń.

json

json(arg1)

Konwertuje prawidłowy ciąg JSON na typ danych JSON.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
arg1 Tak string Wartość, która ma być konwertowana na format JSON. Ciąg musi być poprawnie sformatowany ciąg JSON.

Wartość zwracana

Typ danych JSON z określonego ciągu lub wartość pusta w przypadku określenia wartości null .

Uwagi

Jeśli musisz uwzględnić wartość parametru lub zmienną w obiekcie JSON, użyj funkcji concat , aby utworzyć ciąg przekazywany do funkcji.

Przykład

W poniższym przykładzie pokazano, jak używać funkcji json. Zwróć uwagę, że można przekazać wartość null dla pustego obiektu.

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

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
emptyObjectOutput Wartość logiczna Prawda
objectOutput Objekt {"a": "b"}
stringOutput String test
wartość logicznaOutput Wartość logiczna Prawda
intOutput Integer 3
arrayOutput Tablica [ 1, 2, 3 ]
concatObjectOutput Objekt { "a": "demo value" }

length

length(arg1)

Zwraca liczbę elementów w tablicy, znaki w ciągu lub właściwości na poziomie głównym w obiekcie.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
arg1 Tak tablica, ciąg lub obiekt Tablica do użycia do pobierania liczby elementów, ciągu do użycia do pobierania liczby znaków lub obiektu do pobrania liczby właściwości na poziomie głównym.

Wartość zwracana

Int.

Przykład

W poniższym przykładzie pokazano, jak używać długości z tablicą i ciągiem:

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)

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
arrayLength Int 3
stringLength Int 13
objectLength Int 100

unia

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

Zwraca pojedynczą tablicę lub obiekt ze wszystkimi elementami z parametrów. W przypadku tablic są uwzględniane zduplikowane wartości raz. W przypadku obiektów zduplikowane nazwy właściwości są uwzględniane tylko raz.

Przestrzeń nazw: sys.

Parametry

Parametr Wymagania Type Opis
arg1 Tak tablica lub obiekt Pierwsza wartość, która ma być używana do łączenia elementów.
arg2 Tak tablica lub obiekt Druga wartość, która ma być używana do łączenia elementów.
argumenty dodatkowe Nie. tablica lub obiekt Dodatkowe wartości używane do łączenia elementów.

Wartość zwracana

Tablica lub obiekt.

Uwagi

Funkcja union używa sekwencji parametrów do określenia kolejności i wartości wyniku.

W przypadku tablic funkcja iteruje każdy element w pierwszym parametrze i dodaje go do wyniku, jeśli nie jest jeszcze obecny. Następnie powtarza proces dla drugiego parametru i wszelkich dodatkowych parametrów. Jeśli wartość jest już obecna, jest ona wcześniej umieszczana w tablicy.

W przypadku obiektów nazwy właściwości i wartości z pierwszego parametru są dodawane do wyniku. W przypadku późniejszych parametrów wszystkie nowe nazwy są dodawane do wyniku. Jeśli późniejszy parametr ma właściwość o tej samej nazwie, ta wartość zastępuje istniejącą wartość. Kolejność właściwości nie jest gwarantowana.

Funkcja union scala nie tylko elementy najwyższego poziomu, ale także rekursywnie scala wszystkie zagnieżdżone obiekty w nich. Zagnieżdżone wartości tablicy nie są scalane. Zobacz drugi przykład w poniższej sekcji.

Przykład

W poniższym przykładzie pokazano, jak używać unii z tablicami i obiektami:

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)

Dane wyjściowe z poprzedniego przykładu z wartościami domyślnymi to:

Nazwisko Typ Wartość
objectOutput Objekt {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput Tablica ["one", "two", "three", "four"]

W poniższym przykładzie przedstawiono możliwość głębokiego scalania:

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)

Dane wyjściowe z poprzedniego przykładu to:

Nazwisko Typ Wartość
objectOutput Objekt {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput Tablica [["one","two"],["three"],["four","two"]]

Jeśli zagnieżdżone tablice zostały scalone, wartość objectOutput.nestedArray będzie wynosić [1, 2, 3, 4], a wartość arrayOutput będzie wynosić [["jeden", "dwa", "trzy"], ["trzy", "cztery", "dwa"]].

Następne kroki