Typy danych w Bicep

Artykuł
08/20/2024

W tym artykule opisano typy danych obsługiwane w aplikacji Bicep. Aby zdefiniować niestandardowe typy danych, zobacz Typy danych zdefiniowanych przez użytkownika.

Obsługiwane typy

W obrębie Bicep można użyć następujących typów danych:

tablica
bool
int
object
secureObject — wskazywany przez dekorator w Bicep
secureString — wskazywany przez dekorator w Bicep
string

Tablice

Tablice zaczynają się od lewego nawiasu kwadratowego ([) i kończą się prawym nawiasem kwadratowym (]). W Bicep tablica może być zadeklarowana w jednym wierszu lub wielu wierszach. Przecinki (,) są używane między wartościami w deklaracjach jednowierszowych, ale nie są używane w deklaracjach wielowierszowych, można mieszać i dopasowywać deklaracje jednowierszowe i wielowierszowe. Deklaracja wielowierszowa wymaga interfejsu wiersza polecenia Bicep w wersji 0.7.X lub nowszej.

var multiLineArray = [
  'abc'
  'def'
  'ghi'
]

var singleLineArray = ['abc', 'def', 'ghi']

var mixedArray = ['abc', 'def'
    'ghi']

Każdy element tablicy może być dowolnego typu. Możesz mieć tablicę, w której każdy element jest tym samym typem danych lub tablicą, która zawiera różne typy danych.

W poniższym przykładzie przedstawiono tablicę liczb całkowitych i tablicę różnych typów.

var integerArray = [
  1
  2
  3
]

var mixedArray = [
  resourceGroup().name
  1
  true
  'example string'
]

Tablice w Bicep są oparte na zera. W poniższym przykładzie wyrażenie exampleArray[0] daje w wyniku wartość 1 i exampleArray[2] daje wartość 3. Indeks indeksatora może być innym wyrażeniem. Wyrażenie exampleArray[index] daje wartość 2. Indeksatory liczb całkowitych są dozwolone tylko w wyrażeniu typów tablic.

var index = 1

var exampleArray = [
  1
  2
  3
]

Gdy indeks jest poza granicami, występuje następujący błąd:

The language expression property array index 'x' is out of bounds

Aby uniknąć tego wyjątku, możesz użyć operatora logicznego Or, jak pokazano w poniższym przykładzie:

param emptyArray array = []
param numberArray array = [1, 2, 3]

output foo bool = empty(emptyArray) || emptyArray[0] == 'bar'
output bar bool = length(numberArray) <= 3 || numberArray[3] == 4

Wartości logiczne

Podczas określania wartości logicznych użyj polecenia true lub false. Nie otaczaj wartości znakami cudzysłowu.

param exampleBool bool = true

Liczby całkowite

Podczas określania wartości całkowitych nie używaj cudzysłowów.

param exampleInt int = 1

Liczby całkowite Bicep są 64-bitowymi liczbami całkowitymi. Po przekazaniu jako parametrów wbudowanych zakres wartości może być ograniczony przez zestaw SDK lub narzędzie wiersza polecenia używane do wdrożenia. Na przykład w przypadku wdrażania Bicep przy użyciu programu PowerShell typy całkowite mogą wahać się od -2147483648 do 2147483647. Aby uniknąć tego ograniczenia, określ duże wartości całkowite w pliku parametrów. Typy zasobów stosują własne limity dla właściwości całkowitych.

Bicep obsługuje typ literału liczby całkowitej, który odwołuje się do określonej wartości, która jest dokładną liczbą całkowitą. W poniższym przykładzie 1 jest typem literału liczby całkowitej, foo można przypisać tylko wartość 1 i żadną inną wartość.

output foo 1 = 1

Typ literału liczby całkowitej może być zadeklarowany w tekście, jak pokazano w poprzednim przykładzie lub w instrukcjitype.

type oneType = 1

output foo oneType = 1
output bar oneType = 2

W poprzednim przykładzie przypisanie wartości 2 do paska powoduje błąd BCP033 — oczekiwano wartości typu "1", ale podana wartość ma typ "2".

W poniższym przykładzie pokazano użycie typu literału liczby całkowitej z typem unii:

output bar 1 | 2 | 3 = 3

Formaty zmiennoprzecinkowe, dziesiętne lub binarne nie są obecnie obsługiwane.

Obiekty

Obiekty zaczynają się od lewego nawiasu klamrowego ({) i kończą się prawym nawiasem klamrowym (}). W Bicep obiekt można zadeklarować w jednym wierszu lub wielu wierszach. Każda właściwość w obiekcie składa się z klucza i wartości. Klucz i wartość są oddzielone dwukropkiem (:). Obiekt zezwala na dowolną właściwość dowolnego typu. Przecinki (,) są używane między właściwościami deklaracji jednowierszowych, ale nie są używane między właściwościami deklaracji wielowierszowych. Można mieszać i dopasowywać deklaracje jednowierszowe i wielowierszowe. Deklaracja wielowierszowa wymaga interfejsu wiersza polecenia Bicep w wersji 0.7.X lub nowszej.

param singleLineObject object = {name: 'test name', id: '123-abc', isCurrent: true, tier: 1}

param multiLineObject object = {
  name: 'test name'
  id: '123-abc'
  isCurrent: true
  tier: 1
}

param mixedObject object = {name: 'test name', id: '123-abc', isCurrent: true
    tier: 1}

W Bicep cudzysłowy są opcjonalnie dozwolone w kluczach właściwości obiektu:

var test = {
  'my - special. key': 'value'
}

W poprzednim przykładzie cudzysłowy są używane, gdy klucze właściwości obiektu zawierają znaki specjalne. Na przykład spacja, '-' lub '.'. W poniższym przykładzie pokazano, jak używać interpolacji w kluczach właściwości obiektu.

var stringVar = 'example value'
var objectVar = {
  '${stringVar}': 'this value'
}

Metody dostępu do właściwości są używane do uzyskiwania dostępu do właściwości obiektu. Są one konstruowane przy użyciu . operatora .

var a = {
  b: 'Dev'
  c: 42
  d: {
    e: true
  }
}

output result1 string = a.b // returns 'Dev'
output result2 int = a.c // returns 42
output result3 bool = a.d.e // returns true

Metody dostępu do właściwości mogą być używane z dowolnym obiektem, w tym parametrami i zmiennymi typów obiektów i literałów obiektów. Użycie metody dostępu do właściwości w wyrażeniu typu innego niż obiekt jest błędem.

Możesz również użyć [] składni, aby uzyskać dostęp do właściwości. Poniższy przykład zwraca wartość Development.

var environmentSettings = {
  dev: {
    name: 'Development'
  }
  prod: {
    name: 'Production'
  }
}

output accessorResult string = environmentSettings['dev'].name

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

Podczas uzyskiwania dostępu do nieistniejącej właściwości obiektu występuje następujący błąd:

The language expression property 'foo' doesn't exist

Aby uniknąć wyjątku, możesz użyć operatora logicznego And, jak pokazano w poniższym przykładzie:

param objectToTest object = {
  one: 1
  two: 2
  three: 3
}

output bar bool = contains(objectToTest, 'four') && objectToTest.four == 4

Ciągi

W Bicep ciągi są oznaczone pojedynczymi cudzysłowami i muszą być zadeklarowane w jednym wierszu. Dozwolone są wszystkie znaki Unicode z punktami kodu z zakresu od 0 do 10FFFF .

param exampleString string = 'test value'

W poniższej tabeli wymieniono zestaw znaków zarezerwowanych, które muszą zostać uniknięci przez znak ukośnika odwrotnego (\):

Sekwencja unikowa	Reprezentowana wartość	Uwagi
`\\`	`\`
`\'`	`'`
`\n`	line feed (LF)
`\r`	powrotu karetki (CR)
`\t`	znak tabulacji
`\u{x}`	Punkt kodu Unicode `x`	x reprezentuje wartość punktu kodu szesnastkowego z zakresu od 0 do 10FFFF (włącznie). Zera wiodące są dozwolone. Punkty kodu powyżej FFFF są emitowane jako para zastępcza.
`\$`	`$`	Tylko w przypadku ucieczki, gdy następuje `{`ciąg .

// evaluates to "what's up?"
var myVar = 'what\'s up?'

Bicep obsługuje typ literału ciągu, który odwołuje się do określonej wartości ciągu. W poniższym przykładzie czerwony jest typem literału ciągu, redColor można przypisać tylko wartość czerwoną i żadną inną wartość.

output redColor 'red' = 'red'

Typ literału ciągu można zadeklarować w tekście, jak pokazano w poprzednim przykładzie lub w instrukcjitype.

type redColor = 'red'

output colorRed redColor = 'red'
output colorBlue redColor = 'blue'

W poprzednim przykładzie przypisanie niebieskiego do elementu colorBlue powoduje błąd BCP033 — oczekiwano wartości typu ""czerwony", ale podana wartość jest typu ""niebieski".

W poniższym przykładzie pokazano użycie typu literału ciągu z typem unii:

type direction = 'north' | 'south' | 'east' | 'west'

output west direction = 'west'
output northWest direction = 'northwest'

Wszystkie ciągi w Bicep obsługują interpolację. Aby wstrzyknąć wyrażenie, umieść je w ${ elementach i }. Przywoływane wyrażenia nie mogą obejmować wielu wierszy.

var storageName = 'storage${uniqueString(resourceGroup().id)}'

Ciągi wielowierszowe

W Bicep ciągi wielowierszowe są definiowane między trzema znakami pojedynczego cudzysłowu (''') i opcjonalnie przez nowy wiersz (sekwencja otwierająca) i trzy znaki pojedynczego cudzysłowu (''' — sekwencja zamykająca). Znaki wprowadzone między sekwencją otwierającą i zamykającą są odczytywane dosłownie, a nie jest konieczne ucieczka ani możliwe.

Uwaga

Ponieważ analizator Bicep odczytuje wszystkie znaki w następujący sposób, w zależności od zakończenia wiersza pliku Bicep, nowe linie mogą być interpretowane jako albo \r\n lub \n.

Interpolacja nie jest obecnie obsługiwana w ciągach wielowierszowych. Ze względu na to ograniczenie może być konieczne użycie concat funkcji zamiast interpolacji.

Ciągi wielowierszowe zawierające ''' nie są obsługiwane.

// evaluates to "hello!"
var myVar = '''hello!'''

// evaluates to "hello!" because the first newline is skipped
var myVar2 = '''
hello!'''

// evaluates to "hello!\n" because the final newline is included
var myVar3 = '''
hello!
'''

// evaluates to "  this\n    is\n      indented\n"
var myVar4 = '''
  this
    is
      indented
'''

// evaluates to "comments // are included\n/* because everything is read as-is */\n"
var myVar5 = '''
comments // are included
/* because everything is read as-is */
'''

// evaluates to "interpolation\nis ${blocked}"
// note ${blocked} is part of the string, and is not evaluated as an expression
var myVar6 = '''interpolation
is ${blocked}'''

Typy unii

W Bicep typ unii umożliwia utworzenie połączonego typu składającego się z zestawu podtypów. Przypisanie jest prawidłowe, jeśli dowolne z poszczególnych przypisań podtypów jest dozwolone. Znak | oddziela poszczególne podtypy przy użyciu warunku lub . Na przykład składnia "a" | "b" oznacza, że prawidłowe przypisanie może być "a" lub "b". Typy unii są tłumaczone na ograniczenie dozwolonej wartości w Bicep, więc tylko literały są dozwolone jako elementy członkowskie. Związki mogą zawierać dowolną liczbę wyrażeń typowych literałów.

type color = 'Red' | 'Blue' | 'White'
type trueOrFalse = 'true' | 'false'
type permittedIntegers = 1 | 2 | 3
type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'}
type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]

Związki typu muszą być reducible do pojedynczego typu ARM, takiego jak "string", "int" lub "bool". W przeciwnym razie zostanie wyświetlony kod błędu BCP294 . Na przykład:

type foo = 'a' | 1

Dowolne wyrażenie typu może służyć jako podtyp w deklaracji typu unii (między znakami | ). Na przykład wszystkie poniższe przykłady są prawidłowe:

type foo = 1 | 2
type bar = foo | 3
type baz = bar | (4 | 5) | 6

Typ danych unii z tagiem niestandardowym

Bicep obsługuje niestandardowy otagowany typ danych unii, który służy do reprezentowania wartości, która może być jednym z kilku różnych typów. Aby zadeklarować niestandardowy otagowany typ danych unii, możesz użyć dekoratora @discriminator() . Do korzystania z tego dekoratora wymagany jest interfejs wiersza polecenia Bicep w wersji 0.21.X lub nowszej . Składnia jest następująca:

@discriminator('<property-name>')

Dekorator dyskryminujący przyjmuje jeden parametr, który reprezentuje nazwę właściwości udostępnionej wśród wszystkich składowych unii. Ta nazwa właściwości musi być wymaganym literałem ciągu dla wszystkich elementów członkowskich i uwzględnia wielkość liter. Wartości dyskryminowanej własności członków związku muszą być unikatowe w sposób niewrażliwy na wielkość liter.

type FooConfig = {
  type: 'foo'
  value: int
}

type BarConfig = {
  type: 'bar'
  value: bool
}

@discriminator('type')
param ServiceConfig  FooConfig | BarConfig | { type: 'baz', *: string } = { type: 'bar', value: true }

Wartość parametru jest weryfikowana na podstawie wartości właściwości dyskryminowanej. Na przykład w poprzednim przykładzie, jeśli parametr serviceConfig jest typu foo, jest weryfikowany przy użyciu typu FooConfig . Podobnie, jeśli parametr ma pasek typu, jest weryfikowany przy użyciu typu BarConfig. Ten wzorzec dotyczy również innych typów.

Istnieją pewne ograniczenia dotyczące typu unii.

Typy unii muszą być reducible do pojedynczego typu usługi Azure Resource Manager (ARM). Następująca definicja jest nieprawidłowa:
```
type foo = 'a' | 1
```
Tylko literały są dozwolone jako elementy członkowskie.
Wszystkie literały muszą mieć ten sam typ danych pierwotnych (na przykład wszystkie ciągi lub wszystkie liczby całkowite).

Składnia typu unii może być używana w typach danych zdefiniowanych przez użytkownika.

Zabezpieczanie ciągów i obiektów

Ciąg bezpieczny używa tego samego formatu co ciąg, a bezpieczny obiekt używa tego samego formatu co obiekt. Za pomocą elementu Bicep dodasz @secure() dekorator do ciągu lub obiektu.

Po ustawieniu parametru na bezpieczny ciąg lub bezpieczny obiekt wartość parametru nie jest zapisywana w historii wdrożenia i nie jest rejestrowana. Jeśli jednak ustawisz tę bezpieczną wartość na właściwość, która nie oczekuje bezpiecznej wartości, wartość nie jest chroniona. Jeśli na przykład ustawisz bezpieczny ciąg na tag, ta wartość jest przechowywana jako zwykły tekst. Używaj bezpiecznych ciągów dla haseł i wpisów tajnych.

W poniższym przykładzie przedstawiono dwa bezpieczne parametry:

@secure()
param password string

@secure()
param configValues object

Możliwość przypisywania typów danych

W Bicep wartość jednego typu (typ źródła) można przypisać do innego typu (typ docelowy). W poniższej tabeli przedstawiono typ źródła (wymieniony poziomo) lub nie można przypisać do którego typu docelowego (wymienionego w pionie). W tabeli X oznacza możliwość przypisania, puste miejsce oznacza niemożliwą do przypisania i ? oznacza tylko wtedy, gdy typy są zgodne.

Typy	`any`	`string`	`number`	`int`	`bool`	`null`	`object`	`array`	nazwany zasób	nazwany moduł	`scope`
`any`	X	X	X	X	X	X	X	X	X	X	X
`error`
`string`	X	X
`number`	X		X	X
`int`	X			X
`bool`	X				X
`null`	X					X
`object`	X						X
`array`	X							X
`resource`	X								X
`module`	X									X
`scope`											?
nazwany zasób	X						?		?
nazwany moduł	X						?			?

Następne kroki

Aby dowiedzieć się więcej o strukturze i składni Bicep, zobacz Bicep file structure (Struktura plików Bicep).

Udostępnij za pośrednictwem