Typy danych zdefiniowane przez użytkownika w Bicep
Dowiedz się, jak tworzyć typy danych zdefiniowanych przez użytkownika w aplikacji Bicep. W przypadku typów danych zdefiniowanych przez system zobacz Typy danych.
Składnia
Instrukcję type
można użyć do tworzenia typów danych zdefiniowanych przez użytkownika. Ponadto można również użyć wyrażeń typu w niektórych miejscach do definiowania typów niestandardowych.
type <user-defined-data-type-name> = <type-expression>
Dekorator @allowed
jest dozwolony tylko na param
instrukcjach. Aby zadeklarować typ z zestawem wstępnie zdefiniowanych wartości w obiekcie type
, użyj składni typu unii.
Prawidłowe wyrażenia typów obejmują:
Odwołania symboliczne to identyfikatory odwołujące się do typu otoczenia (na przykład
string
lubint
) lub symbolu typu zdefiniowanego przez użytkownika zadeklarowanego w instrukcjitype
:// Bicep data type reference type myStringType = string // user-defined type reference type myOtherStringType = myStringType
Literały pierwotne, w tym ciągi, liczby całkowite i wartości logiczne, są prawidłowymi wyrażeniami typów. Na przykład:
// a string type with three allowed values. type myStringLiteralType = 'bicep' | 'arm' | 'azure' // an integer type with one allowed value type myIntLiteralType = 10 // an boolean type with one allowed value type myBoolLiteralType = true
Typy tablic można zadeklarować, dołączając
[]
do dowolnego prawidłowego wyrażenia typu:// A string type array type myStrStringsType1 = string[] // A string type array with three allowed values type myStrStringsType2 = ('a' | 'b' | 'c')[] type myIntArrayOfArraysType = int[][] // A mixed-type array with four allowed values type myMixedTypeArrayType = ('fizz' | 42 | {an: 'object'} | null)[]
Typy obiektów zawierają zero lub więcej właściwości między nawiasami klamrowymi:
type storageAccountConfigType = { name: string sku: string }
Każda właściwość w obiekcie składa się z klucza i wartości rozdzielonej dwukropkiem
:
. Klucz może być dowolnym ciągiem, z wartościami nieidentyfikatora ujętymi w cudzysłów, a wartość może być dowolnym typem wyrażenia.Właściwości są wymagane, chyba że mają znacznik
?
opcjonalności po wartości właściwości. Na przykład właściwość w poniższym przykładziesku
jest opcjonalna:type storageAccountConfigType = { name: string sku: string? }
Dekoratory mogą być używane we właściwościach.
*
Może służyć do określania, że wszystkie wartości wymagają ograniczenia. Dodatkowe właściwości można nadal definiować w przypadku używania polecenia*
. W tym przykładzie tworzony jest obiekt, który wymaga klucza typuint
o nazwie id, a wszystkie inne wpisy w obiekcie muszą być wartością ciągu co najmniej 10 znaków.type obj = { @description('The object ID') id: int @description('Additional properties') @minLength(10) *: string }
W poniższym przykładzie pokazano, jak używać składni typu unii do wyświetlania listy wstępnie zdefiniowanych wartości:
type directions = 'east' | 'south' | 'west' | 'north' type obj = { level: 'bronze' | 'silver' | 'gold' }
Rekursja
Typy obiektów mogą używać rekursji bezpośredniej lub pośredniej, o ile co najmniej część ścieżki do punktu rekursji jest opcjonalna. Na przykład definicja w poniższym przykładzie jest prawidłowa,
myObjectType
ponieważ właściwość bezpośrednia rekursywnarecursiveProp
jest opcjonalna:type myObjectType = { stringProp: string recursiveProp: myObjectType? }
Jednak następująca definicja typu nie byłaby prawidłowa, ponieważ żadna z wartości
level1
,level2
,level3
,level4
lublevel5
nie jest opcjonalna.type invalidRecursiveObjectType = { level1: { level2: { level3: { level4: { level5: invalidRecursiveObjectType } } } } }
Operatory jednoargumentowe Bicep mogą być używane z literałami całkowitymi i logicznymi lub odwołaniami do symboli typu całkowitoliczbowego lub logicznego:
type negativeIntLiteral = -10 type negatedIntReference = -negativeIntLiteral type negatedBoolLiteral = !true type negatedBoolReference = !negatedBoolLiteral
Związki mogą zawierać dowolną liczbę wyrażeń typowych literałów. Typy unii są tłumaczone na ograniczenie dozwolonej wartości w Bicep, więc tylko literały są dozwolone jako elementy członkowskie.
type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'} type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]
Oprócz użycia w instrukcji type
wyrażenia typu można również używać w tych miejscach do tworzenia typów danych zdefiniowanych przez użytkownika:
Jako klauzula
param
type instrukcji. Na przykład:param storageAccountConfig { name: string sku: string }
:
Po właściwości w typie obiektu. Na przykład:param storageAccountConfig { name: string properties: { sku: string } } = { name: 'store$(uniqueString(resourceGroup().id)))' properties: { sku: 'Standard_LRS' } }
Poprzedzając element
[]
w wyrażeniu typu tablicy. Na przykład:param mixedTypeArray ('fizz' | 42 | {an: 'object'} | null)[]
Typowy plik Bicep do utworzenia konta magazynu wygląda następująco:
param location string = resourceGroup().location
param storageAccountName string
@allowed([
'Standard_LRS'
'Standard_GRS'
])
param storageAccountSKU string = 'Standard_LRS'
resource storageAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
name: storageAccountName
location: location
sku: {
name: storageAccountSKU
}
kind: 'StorageV2'
}
Korzystając z typów danych zdefiniowanych przez użytkownika, może to wyglądać następująco:
param location string = resourceGroup().location
type storageAccountSkuType = 'Standard_LRS' | 'Standard_GRS'
type storageAccountConfigType = {
name: string
sku: storageAccountSkuType
}
param storageAccountConfig storageAccountConfigType
resource storageAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
name: storageAccountConfig.name
location: location
sku: {
name: storageAccountConfig.sku
}
kind: 'StorageV2'
}
Podnoszenie poziomu błędu
Domyślnie deklarowanie typu obiektu w Bicep umożliwia akceptowanie dodatkowych właściwości dowolnego typu. Na przykład następujący Bicep jest prawidłowy, ale zgłasza ostrzeżenie [BCP089] - The property "otionalProperty" is not allowed on objects of type "{ property: string, optionalProperty: null | string }". Did you mean "optionalProperty"?
:
type anObject = {
property: string
optionalProperty: string?
}
param aParameter anObject = {
property: 'value'
otionalProperty: 'value'
}
Ostrzeżenie informuje o tym, że typ obiektu anObject nie zawiera właściwości o nazwie otionalProperty. Chociaż podczas wdrażania nie występują żadne błędy, kompilator Bicep zakłada , że otionalProperty jest literówką , którą zamierzasz użyć opcjonalnej właściwości , ale błędnie ją wpisać i powiadomić o niespójności.
Aby eskalować te ostrzeżenia do błędów, zastosuj @sealed()
dekorator do typu obiektu:
@sealed()
type anObject = {
property: string
optionalProperty?: string
}
Te same wyniki można uzyskać, stosując @sealed()
dekorator do deklaracji param
:
type anObject = {
property: string
optionalProperty: string?
}
@sealed()
param aParameter anObject = {
property: 'value'
otionalProperty: 'value'
}
Aparat wdrażania usługi ARM sprawdza również zapieczętowane typy pod kątem dodatkowych właściwości. Podanie dodatkowych właściwości dla zapieczętowanych parametrów powoduje błąd weryfikacji, powodując niepowodzenie wdrożenia. Na przykład:
@sealed()
type anObject = {
property: string
}
param aParameter anObject = {
property: 'value'
optionalProperty: 'value'
}
Oznakowany typ danych unii
Aby zadeklarować niestandardowy otagowany typ danych unii w pliku Bicep, można umieścić discriminator
dekorator powyżej deklaracji typu zdefiniowanego przez użytkownika. Do korzystania z tego dekoratora wymagany jest interfejs wiersza polecenia Bicep w wersji 0.21.X lub nowszej . W poniższym przykładzie pokazano, jak zadeklarować oznakowany typ danych unii:
type FooConfig = {
type: 'foo'
value: int
}
type BarConfig = {
type: 'bar'
value: bool
}
@discriminator('type')
type ServiceConfig = FooConfig | BarConfig | { type: 'baz', *: string }
param serviceConfig ServiceConfig = { type: 'bar', value: true }
output config object = serviceConfig
Aby uzyskać więcej informacji, zobacz Niestandardowy otagowany typ danych unii.
Importowanie typów między plikami Bicep
Do innych szablonów można zaimportować tylko typy danych zdefiniowane przez użytkownika, które mają @export()
dekorator.
Poniższy przykład umożliwia importowanie dwóch typów danych zdefiniowanych przez użytkownika z innych szablonów:
@export()
type myStringType = string
@export()
type myOtherStringType = myStringType
Aby uzyskać więcej informacji, zobacz Importowanie typów danych zdefiniowanych przez użytkownika.
Następne kroki
- Aby uzyskać listę typów danych Bicep, zobacz Typy danych.