Uživatelem definované datové typy v Bicep

  • Článek

Naučte se používat uživatelem definované datové typy v Bicep.

K použití této funkce se vyžaduje rozhraní příkazového řádku Bicep verze 0.12.X nebo vyšší .

Syntaxe datového typu definovaná uživatelem

Příkaz můžete použít type k definování uživatelem definovaných datových typů. Kromě toho můžete k definování vlastních typů použít také výrazy typu na některých místech.

type <user-defined-data-type-name> = <type-expression>

Poznámka:

Dekorátor @allowed je povolen pouze u param příkazů. Chcete-li deklarovat, že vlastnost musí být jednou ze sady předdefinovaných hodnot v type příkazu nebo output příkazu, použijte syntaxi sjednocovacího typu. Syntaxi typu sjednocení lze použít také v param příkazech.

Mezi platné výrazy typu patří:

  • Symbolické odkazy jsou identifikátory, které odkazují na okolní typ (například string nebo int) nebo symbol definovaného uživatelem type deklarovaný v příkazu:

    // Bicep data type reference
type myStringType = string

// user-defined type reference
type myOtherStringType = myStringType

  • Primitivní literály, včetně řetězců, celých čísel a logických hodnot, jsou platné výrazy typu. Příklad:

    // 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 polí lze deklarovat příponou [] libovolného platného výrazu 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 objektů obsahují nula nebo více vlastností mezi složenými závorkami:

    type storageAccountConfigType = {
  name: string
  sku: string
}

    Každá vlastnost v objektu se skládá z klíče a hodnoty. Klíč a hodnota jsou odděleny dvojtečka :. Klíč může být libovolný řetězec (hodnoty, které by nebyl platný identifikátor, musí být uzavřeny v uvozovkách) a hodnota může být libovolný výraz syntaxe typu.

    Vlastnosti jsou vyžadovány, pokud nemají za hodnotou vlastnosti značku ? volitelné vlastnosti. Například vlastnost v následujícím příkladu sku je volitelná:

    type storageAccountConfigType = {
  name: string
  sku: string?
}

    Dekorátory lze použít u vlastností. * lze použít k tomu, aby všechny hodnoty vyžadovaly omezení. Při použití *mohou být stále definovány další vlastnosti . Tento příklad vytvoří objekt, který vyžaduje klíč typu int s názvem id, a že všechny ostatní položky v objektu musí být řetězcová hodnota nejméně 10 znaků dlouhé.

    type obj = {
  @description('The object ID')
  id: int

  @description('Additional properties')
  @minLength(10)
  *: string
}

    Následující ukázka ukazuje, jak pomocí syntaxe sjednocovacího typu vypsat sadu předdefinovaných hodnot:

    type obj = {
  level: 'bronze' | 'silver' | 'gold'
}

    Rekurze

    Typy objektů můžou používat přímé nebo nepřímé rekurze, pokud je alespoň noha cesty k bodu rekurze volitelná. Například definice v následujícím příkladu myObjectType je platná, protože přímo rekurzivní recursiveProp vlastnost je volitelná:

    type myObjectType = {
  stringProp: string
  recursiveProp: myObjectType?
}

    Následující definice typu by ale nebyla platná, protože žádná z level1, level2, level3, level4, nebo level5 je nepovinná.

    type invalidRecursiveObjectType = {
  level1: {
    level2: {
      level3: {
        level4: {
          level5: invalidRecursiveObjectType
        }
      }
    }
  }
}

  • Unární operátory Bicep lze použít s celočíselnou a logickou literály nebo odkazy na celočíselné nebo logické symboly typu literál:

    type negativeIntLiteral = -10
type negatedIntReference = -negativeIntLiteral

type negatedBoolLiteral = !true
type negatedBoolReference = !negatedBoolLiteral

  • Sjednocení můžou obsahovat libovolný počet výrazů typu literál. Typy sjednocení se překládají do omezení povolené hodnoty v Bicep, takže jako členy jsou povoleny pouze literály.

    type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'}
type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]

Kromě použití v type příkazu je možné výrazy typů použít také na těchto místech pro vytváření uživatelsky definovaných datových typů:

  • Jako klauzule param typu příkazu. Příklad:

    param storageAccountConfig {
  name: string
  sku: string
}

  • Následuje za : vlastností typu objektu. Příklad:

    param storageAccountConfig {
 name: string
  properties: {
    sku: string
  }
} = {
  name: 'store$(uniqueString(resourceGroup().id)))'
  properties: {
    sku: 'Standard_LRS'
  }
}

  • [] Předchází výrazu typu pole. Příklad:

    param mixedTypeArray ('fizz' | 42 | {an: 'object'} | null)[]

Typický soubor Bicep pro vytvoření účtu úložiště vypadá takto:

param location string = resourceGroup().location
param storageAccountName string

@allowed([
  'Standard_LRS'
  'Standard_GRS'
])
param storageAccountSKU string = 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountSKU
  }
  kind: 'StorageV2'
}

Pomocí uživatelem definovaných datových typů může vypadat takto:

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@2022-09-01' = {
  name: storageAccountConfig.name
  location: location
  sku: {
    name: storageAccountConfig.sku
  }
  kind: 'StorageV2'
}

Deklarace označeného typu sjednocení

Pokud chcete deklarovat vlastní sjednocovací datový typ v souboru Bicep, můžete diskriminátor umístit nad deklarování typu definovaného uživatelem. K použití tohoto dekorátoru se vyžaduje rozhraní příkazového řádku Bicep verze 0.21.X nebo vyšší . Syntaxe je:

@discriminator('<propertyName>')

Nediskriminační dekorátor přebírá jeden parametr, který představuje název sdílené vlastnosti mezi všemi členy sjednocení. Tento název vlastnosti musí být povinný řetězcový literál pro všechny členy a rozlišují se malá a velká písmena. Hodnoty diskriminované vlastnosti členů sjednocení musí být jedinečné způsobem bez rozlišování malých a malých písmen.

Následující příklad ukazuje, jak deklarovat označený typ sjednocení:

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

Hodnota parametru je ověřena na základě diskriminované hodnoty vlastnosti. Pokud je hodnota parametru serviceConfig v předchozím příkladu typu foo, prochází ověřením pomocí typu FooConfig. Podobně platí, že pokud je hodnota parametru typu pruh, provede se ověření pomocí typu BarConfig a tento vzor bude pokračovat i pro jiné typy.

Import typů mezi soubory Bicep (Preview)

K použití této funkce importu v čase kompilace se vyžaduje rozhraní příkazového řádku Bicep verze 0.21.X nebo vyšší . Experimentální příznak compileTimeImports musí být povolený z konfiguračního souboru Bicep.

Do jiných šablon lze importovat pouze uživatelem definované datové typy, které nesou @export() dekorátor. V současné době lze tento dekorátor použít pouze u type příkazů.

Následující příklad umožňuje importovat dva uživatelem definované datové typy z jiných šablon:

@export()
type myStringType = string

@export()
type myOtherStringType = myStringType

Další informace naleznete v tématu Import uživatelem definovaných datových typů.

Další kroky

  • Seznam datových typů Bicep najdete v tématu Datové typy.