Կոնֆիգուրացիայի սկեմա/մետատվյալներ

Drupal 8 ներառում է YAML կոնֆիգուրացիոն ֆայլերի համար նախատեսված Kwalify-ի (http://www.kuwata-lab.com/kwalify/) կողմից ստեղծված սխեմայի/մետատվյալների լեզվի աջակցություն: Ինքնին Kwalify-ն գրված է Ruby լեզվով, և մեզ անհրաժեշտ էին փոքր փոփոխություններ ֆորմատում, ուստի Kwalify-ի բոլոր մանրամասները անմիջապես չեն կիրառվում, սակայն շատ մոտ են դրան:

Շապիկ

Արագ ըմբռնման և հարմար օրինակների համար դիտեք այս շապիկը, ապա շարունակեք կարդալ, եթե դեռ հարցեր ունեք՝

/sites/default/files/config-schema-cheat-sheet1.5.pdf

Ներդրման օրինակ

System մոդուլը ունի երկու կոնֆիգուրացիոն պարամետրեր՝ կապված սպասարկման ռեժիմի հետ (կայքը հասանելի է կամ ոչ սովորական այցելուների համար):

<?php
$config = \Drupal::config('system.maintenance');
$message = $config->get('message');
$langcode = $config->get('langcode');
?>

(Թե սպասարկումը ակտիվ է, պահվում է state system համակարգում, ոչ թե կոնֆիգուրացիայում):

Այս կոնֆիգուրացիայի նորմալ արժեքները պահվում են core/modules/system/config/install/system.maintenance.yml ֆայլում՝ հետևյալ ձևով՝

message: '@site is currently under maintenance. We should be back shortly. Thank you for your patience.'
langcode: en

Յուրաքանչյուր մոդուլ կարող է ունենալ անհրաժեշտության դեպքում բազմաթիվ կոնֆիգուրացիոն օբյեկտներ։ Սրանք բոլորը բացատրվում են մեկ կամ ավելի սխեմայի ֆայլերում, որոնք առաքվում են մոդուլի հետ։ System մոդուլի դեպքում ֆայլերը գտնվում են core/modules/system/config/schema. system.schema.yml ֆայլի համապատասխան հատվածը տեսեք ստորև՝

system.maintenance:
  type: config_object
  label: 'Maintenance mode'
  mapping:
    message:
      type: text
      label: 'Message to display when in maintenance mode'

Ֆայլի վերին մակարդակի բանալին ("system.maintenance") համապատասխանում է .yml ֆայլի հիմնական անունին ("system.maintenance.yml") և կոնֆիգուրացիայի օբյեկտի անվանմանը (config('system.maintenance')). Ներքևի մակարդակները նկարագրում են ֆայլի պարունակությունը։ Կոնֆիգուրացիայի սխեման սահմանում է երկու տեսակի ֆայլեր՝ config_object գլոբալ կոնֆիգուրացիայի ֆայլերի համար և config_entity՝ էնթիթիների համար։ config_object տեսակը սահմանված է core.data_types.schema.yml ֆայլում՝ հետևյալ կերպ՝

# Root of a configuration object.

_core_config_info:
  type: mapping
  mapping:
    default_config_hash:
      type: string
      label: 'Default configuration hash'

config_object:
  type: mapping
  mapping:
    langcode:
      type: string
      label: 'Language code'
    _core:
      type: _core_config_info

Mapping (ներդրված տիպ) հանդիսանում է բանալի-արժեք զույգերի հիմնական տիպ։ config_object տեսակը կրկնակի օգտագործում է langcode և _core բանալիները և ավելացնում է ևս մեկ բանալի՝ message-ի համար։ system.maintenance-ի սխեմայի նշանն (label)՝ «Maintenance mode», նկարագրում է սխեմայի բովանդակությունը։ Հետո փաստացի տարրերը նկարագրված են mapping բանալիի ներքո, որտեղ message բանալին սահմանվում է՝ ժառանգելով langcode և _core բանալիները։ Յուրաքանչյուր տարր ունի type և label, որոնք համապատասխանաբար նկարագրում են տվյալների տիպն ու նրանց նկարագրությունը։ Label-ը սովորաբար համարվում է նույնը կամ մոտավորապես նման է կոնֆիգուրացիոն ձևի label-ին, որտեղ արժեքը կարող է խմբագրվել համակարգի ադմինիստրատորի կողմից։

Բոլոր դեպքերում, որոնք աջակցվում են Drupal-ի կողմից, .yml ֆայլի վերին մակարդակի տարրը պետք է լինի mapping (տպավորություն)՝ ներառյալ ստորև նկարագրված բանալիներով։ Դուք պետք է օգտագործեք նշված երկու ենթատեսակներից որևէ մեկը՝ config_object կամ config_entity։ Տարբեր տարրերը կարող են ունենալ ցանկացած տիպ՝ կախված տվյալների նկարագրությունից։ _core բանալին և դրա բոլոր ենթաբանալները պահվում են Drupal-ի միջուկի կողմից։

Ինչի՞ համար են սխեմայի ֆայլերը

1. Գլխավոր օգտագործման դեպքերը ներկայացվել են բազմալեզու աջակցության համար։ Հնարավոր է գտնել բոլոր թարգմանվող տեքստերը, որոնք առկա են կոնֆիգուրացիայում, որպեսզի ձեր մոդուլի կամ թեմայի տեղադրման հետ միասին դրանց համար առաջարկվեն թարգմանություններ https://localize.drupal.org կայքում։ Այս օգտագործման դեպքում բավական է միայն սխեմայի մակարդակները և տիպերը։

2. Սխեմաները օգտագործվում են նաև տվյալների հիման վրա ստեղծվող թարգմանական ձևեր տրամադրելու համար։ Այս դեպքում տիպերը կարևոր են, իսկ label-ները պետք է ճշգրիտ լինեն։ Կոնֆիգուրացիայի թարգմանության մոդուլը օգտագործում է սխեմաները՝ թարգմանական ձևերի ստեղծման և թարգմանությունների պահպանման համար։ Հիմնական թարգմանվող տիպերը «label» են (մեկ տող տեքստ) և «text» (բազմալայն տեքստ):

3. Սխեմաները օգտագործվում են նաև կոնֆիգուրացիայի օբյեկտների ինքնավար պահպանության համար։ Դրա համար անհրաժեշտ է կոնֆիգուրացիայի օբյեկտի սխեմա, որպեսզի ճիշտ արտահանվեն տիպավորված հատկությունները։ Եթե դուք չեք ցանկանում տրամադրել սխեմա, անհրաժեշտ է իրագործել toArray() մեթոդը կոնֆիգուրացիայի էնթիթիում՝ պահպանման համար։

4. Սխեմաները ապահովում են ավտոմատ տիպավորում՝ երաշխավորելով, որ կոնֆիգուրացիայի արժեքները պահվում են ճիշտ տիպերով։ Սա կարևոր է, որպեսզի տարբերակների վերահաշվարկը ցույց տա միայն իսկական փոփոխությունները։

5. PHPUnit-ում Բոլոր TestBase դասեր սահմանում են խիստ սխեմայի հետևում։ Եթե սխեման բացակայում է կամ սխալ է, կհայտնվեն սխալներ։ Եթե հարկավոր է, կարող եք թուլացնել ստուգումը՝ սահմանելով՝

protected $strictConfigSchema = FALSE;

Դիտեք https://drupal.org/project/config_inspector մոդուլը, որն օգնում է սխեմաներն ստուգել։ Այն օգնում է գտնել բացակա սխեմաներ և սխեմայի տարրեր՝ տարբեր ներկայացումներով:

Կան նաև այլ հնարավորություններ սխեմաների օգտագործման համար, օրինակ՝ վեբսերվիսների ինտերֆեյսների ստեղծում, և հնարավոր է, որ հետագայում հայտնվեն նոր օգտագործման դեպքեր:

Հատկություններ

• type՝ արժեքի տիպ, կարող է լինել հիմնական կամ ժառանգված տիպ։
• label՝ UI-ում ցուցադրվող անվանում, կարող է տարբերվել կոնֆիգուրացիոն ձևի անվանումից, բայց ավելի լավ է համընկնում ունենա։
• translatable՝ տիպի թարգմանելիություն, օրինակ՝

type: label

ինչպես կարճակյաց է նույնը, ինչ՝

type: string
translatable: true

• nullable՝ հնարավոր է, որ արժեքը դատարկ լինի։
• class՝ օգտագործվում է հիմնական տիպերի համար՝ կոդի վերլուծության դասի համար։
• Տիպին հատուկ հատկություններ՝

          - mapping՝ mapping տիպի արժեքների համար, որտեղ բանալիներն ու արժեքների տիպերը պետք է սահմանվեն սխեմայում։ Mapping-ում բանալիները միայն տեքստային են։
          - sequence՝ sequence տիպի արժեքների համար, որտեղ բանալիները կարող են լինել թվեր կամ տեքստ, բայց նշանակություն չունեն։

Մետատվյալների տիպերը

Նախապես սահմանված հիմնական տիպերն ու մի քանի բարդ տիպեր կարելի է գտնել core.data_types.schema.yml-ում՝

# Undefined type used by the system to assign to elements at any level where
# configuration schema is not defined. Using explicitly has the same effect as
# not defining schema, so there is no point in doing that.
undefined:
  label: 'Undefined'
  class: '\Drupal\Core\Config\Schema\Undefined'

# Explicit type to use when no data typing is possible. Instead of using this
# type, we strongly suggest you use configuration structures that can be
# described with other structural elements of schema, and describe your schema
# with those elements.
ignore:
  label: 'Ignore'
  class: '\Drupal\Core\Config\Schema\Ignore'

# Basic scalar data types from typed data.
boolean:
  label: 'Boolean'
  class: '\Drupal\Core\TypedData\Plugin\DataType\BooleanData'
email:
  label: 'Email'
  class: '\Drupal\Core\TypedData\Plugin\DataType\Email'
integer:
  label: 'Integer'
  class: '\Drupal\Core\TypedData\Plugin\DataType\IntegerData'
float:
  label: 'Float'
  class: '\Drupal\Core\TypedData\Plugin\DataType\FloatData'
string:
  label: 'String'
  class: '\Drupal\Core\TypedData\Plugin\DataType\StringData'
uri:
  label: 'Uri'
  class: '\Drupal\Core\TypedData\Plugin\DataType\Uri'

Ինչպես երևում է, հիմնական տիպերի մեծամասնությունը համապատասխանում է TypedData API-ի համապատասխան տիպերին։ Սա ցույց է տալիս նաև, թե ինչպես կարող եք հեշտությամբ սահմանել ձեր սեփական տիպերը՝ պարզապես ստեղծելով համապատասխան դաս։ Մնացած երկու բարդ տիպերը սահմանված են համապատասխան դասերի հիման վրա՝

# Container data types for lists with known and unknown keys.
mapping:
  label: Mapping
  class: '\Drupal\Core\Config\Schema\Mapping'
  definition_class: '\Drupal\Core\TypedData\MapDataDefinition'
sequence:
  label: Sequence
  class: '\Drupal\Core\Config\Schema\Sequence'
  definition_class: '\Drupal\Core\TypedData\ListDataDefinition'

Mapping-ը, ինչպես ցույց է տրված, բանալի-արժեք զույգերի ( ասոցատիվ զանգվածի ) տիպ է, որտեղ յուրաքանչյուր տարր կարող է ունենալ տարբեր տիպ, իսկ Sequence-ը՝ ինդեքսավորված զանգված է, որտեղ տարրերը ունեն նույն տիպը, և բանալիներն նշանակություն չունեն։ Sequence-ում բանալիները կարող են լինել տեքստային։

Մնացած տիպերը, ներառյալ system.maintenance-ն, ժառանգում են մյուս տիպերից, օրինակ՝ label, path, text, date_format, color_hex, որոնք սահմանված են որպես տողեր, բայց տարբերակում են տեքստային տիպերը տարբեր նպատակների համար։

# Human readable string that must be plain text and editable with a text field.
label:
  type: string
  label: 'Label'
  translatable: true

# Internal Drupal path
path:
  type: string
  label: 'Path'

# Human readable string that can contain multiple lines of text or HTML.
text:
  type: string
  label: 'Text'
  translatable: true

# PHP Date format string that is translatable.
date_format:
  type: string
  label: 'Date format'
  translatable: true
  translation context: 'PHP date format'

# HTML color value.
color_hex:
  type: string
  label: 'Color'

Ուշադրություն դարձրեք, որ label, text և date_format տիպերը նշված են որպես թարգմանելի։ Սա նշանակում է, որ հիմնական ինտերֆեյսի թարգմանության մոդուլը դրանք որոնում և թարգմանում է տվյալների բազայի կամ համայնքի կողմից տրամադրված թարգմանություններով, ստեղծելով թարգմանության վերաուղղման ֆայլեր։ Թարգմանելի տեքստերը կարող են ունենալ թարգմանության համատեքստ՝ ինչպես ցույց է տրված date_format-ի համար, որպեսզի թարգմանողները գիտակցեն, որ օրինակ «Y»-ը PHP ամսաթվի ֆորմատ է, ոչ թե այո։

Այդպես կարելի է նաև վերաօգտագործվող բարդ տիպեր սահմանել հիմնական տիպերի վրա, ինչպես տեսանք սպասարկման ռեժիմի օրինակով՝

# Mail text with subject and body parts.
mail:
  type: mapping
  label: 'Mail'
  mapping:
    subject:
      type: label
      label: 'Subject'
    body:
      type: text
      label: 'Body'

Սա թույլ է տալիս ունենալ mail տիպ՝ էլ․ փոստի թեմայի և մարմնի համար, որը կարող է օգտագործվել այլ տեղ։ Օրինակ user.schema.yml-ում՝

user.mail:
 type: config_object
 label: 'Email settings'
 mapping:
  cancel_confirm:
    type: mail
    label: 'Account cancellation confirmation'
  password_reset:
    type: mail
    label: 'Password recovery'
  [....]

Վերջում նշենք ևս երկու կարևոր բարդ տիպ՝ config_object և config_entity, որոնք սահմանված են core.data_types.schema.yml-ում՝

config_object:
  type: mapping
  mapping:
    langcode:
      type: string
      label: 'Language code'
    _core:
      type: _core_config_info

config_entity:
  type: mapping
  mapping:
    uuid:
      type: string
      label: 'UUID'
    langcode:
      type: string
      label: 'Language code'
    status:
      type: boolean
      label: 'Status'
    dependencies:
      type: config_dependencies
      label: 'Dependencies'
    third_party_settings:
      type: sequence
      label: 'Third party settings'
      sequence:
        type: '[%parent.%parent.%type].third_party.[%key]'
    _core:
      type: _core_config_info

Դինամիկ տիպերի հղումներ

Ինչպես նշվեց վերևում, նույնիսկ պարզ տիպերը հիմնականում հղումներ են, իսկ բարդ տիպերը՝ օրինակ mail-ը, օգտագործվում են որպես վերանվանված տիպեր։ Որոշ դեպքերում տիպը կախված է տվյալներից, օրինակ պատկերների ոճերի դեպքում, որտեղ տարբեր էֆեկտներ կարող են կիրառվել, կամ view-ների դեպքում՝ տարբեր պլագիններով։ Դրա համար հնարավոր է տիպերը սահմանել տվյալների բանալիների միջոցով։

Տիպի փոփոխական արժեքները պետք է լինեն [] ներքո, և հնարավոր է համակցել որոշ գիտելիքներ։ Տիպային հղումների երեք տեսակ կա՝

1. Տարրի բանալիի հղում՝ օրինակ type: book.[%key], որտեղ %key-ն փոխարինվում է տարրի բանալով։
2. Ներառված բանալիի հղում՝ օրինակ type: 'views.field.[table]-[field]', որտեղ տիպը հաշվարկվում է հիման վրա table և field բանալիների։
3. Մայր բանալիի հղում՝ օրինակ type: 'views.display.[%parent.display_plugin]', որտեղ parent-ի display_plugin բանալին օգտագործվում է տիպը որոշելու համար։

Օրինակ պատկերների ոճերից՝ core/modules/image/config/install/image.style.medium.yml, որը ունի այս կառուցվածքը՝

name: medium
label: 'Medium (220x220)'
effects:
  bddf0d06-42f9-4c75-a700-a33cafa25ea0:
    id: image_scale
    data:
      width: 220
      height: 220
      upscale: true
    weight: 0
    uuid: bddf0d06-42f9-4c75-a700-a33cafa25ea0
langcode: en

Այստեղ effects բանալիի կառուցվածքը կախված է id էֆեկտի տիպից։ Այդ պատճառով տիպը տվյալների վրա է հիմնված և չի կարող լինել ստատիկ։ Այս սխեմայի համապատասխան մասը՝ image.schema.yml ֆայլում է՝

image.style.*:
  type: config_entity
  label: 'Image style'
  mapping:
    name:
      type: string
    label:
      type: label
      label: 'Label'
    effects:
      type: sequence
      sequence:
        type: mapping
        mapping:
          id:
            type: string
          data:
            type: image.effect.[%parent.id]
          weight:
            type: integer
          uuid:
            type: string

Սա նկարագրում է բոլոր պատկերների ոճերի մետատվյալները՝ անուններ, նշաններ և էֆեկտների բանալիներ։ Հետևաբար effects-ը հաջորդականություն է, որտեղ յուրաքանչյուր տարր՝ մապինգ է՝ id, data, weight, uuid բանալիներով։ data-ն կախված է id-ից, որը դրված է տվյալ էֆեկտի մեջ։ Այդպիսով, image.effect.image_scale տիպը վավեր է տվյալների համար։

Նշենք, որ նաև կարելի է հանդիպել sequence-ի այլ ձևաչափի, որտեղ sequence-ի տարրերի տիպը սահմանված է որպես միակ տարրերի ցուցակ։ Այս ձևաչափը հնացած է և կհանվի Drupal 9-ում՝

deprecated.sequence.definition.format:
  type: sequence
  sequence:
    - type: string
      label: 'DO NOT COPY, THIS IS DEPRECATED'

Ձեր սխեմայի ֆայլերի անունները

Ձեր սխեմայի ֆայլերը պետք է ունենան գլոբալ եզակի անուն։ Եթե ձեր սխեմայի ֆայլի անունը համընկնի այլ հավելման ֆայլի անվան հետ, մեկ կամ երկու սխեմաները չեն բեռնվի, ինչը կհանգեցնի բարդ սխալների։ Հետևաբար խորհուրդ է տրվում սխեմայի ֆայլերի անուններին ավելացնել մոդուլի անվան պրեֆիքս։

Կոդի ոճը սխեմայի ֆայլերում

Պարզապես հետևեք .yml ֆայլերի կոդավորման ընդհանուր ոճին Drupal միջուկում։ Ստորև նշված կարևոր կետերն են՝

• Ներկայացրեք վերին մակարդակի մեկնաբանություն, որը բացատրում է ֆայլի բովանդակությունը։ Եթե ունեք մեկ սխեմայի ֆայլ ամբողջ մոդուլի համար, բավական է օրինակ՝ # Schema for the configuration files of the Contact module։
• Խուսափեք ավելորդ մեկնաբանություններից, որոնք չեն ավելացնում հստակություն։
• Մի օգտագործեք երկկողմանի ստորակետներ (կամ՝ դյուալ չակերտներ) տողերի համար, օգտագործեք միայն միակողմանի ստորակետներ՝ համազորության համար։
• Մետա տեքստի արժեքների համար նույնպես օգտագործեք միակողմանի ստորակետներ, նույնիսկ եթե դրանք մեկ բառ են։
• Բանալիների անունների և տիպերի համար չկիրառեք չակերտներ (դրանք միշտ տեքստ են, և չպետք է բացատներ ունենան)։
• ՅAML-ում թվային արժեքները, որոնք պահվում են կոնֆիգուրացիոն ֆայլերում, ավտոմատ կերպով վերածվում են տեքստի և պահվում միակողմանի ստորակետերով։
• Անհրաժեշտության դեպքում ավելացրեք label-ներ՝ թարգմանելի արժեքների և նրանց պարունակող կոնտեյներների համար։
• Շարունակեք ճիշտ ինդենտացիան՝ քանի որ YAML-ում դա կարևոր է ճիշտ կառուցվածքի համար։

Նշում. Կոնֆիգուրացիայի տվյալների .yml ֆայլերի կոդավորման ստանդարտը պահանջում է օգտագործել միակողմանի ստորակետներ միայն այն ժամանակ, երբ օգտագործվում է ավելի քան մեկ բառ, ինչը հեշտացնում է կոնֆիգուրացիայի փոփոխումը։ Սխեմաների ֆայլերի առաջարկները տարբերվում են, քանի որ դրանք ձեռքով են գրվում, ուստի խորհուրդ է տրվում միշտ օգտագործել ստորակետներ՝ label արժեքների համար։

PHP API

Կոնֆիգուրացիայի մետատվյալները ստանալու համար կարող եք օգտագործել \Drupal::service('config.typed') ֆունկցիան, օրինակ system.maintenance-ի համար՝

$definition = \Drupal::service('config.typed')->getDefinition('system.maintenance');

Արդյունքում ստացված զանգվածի կառուցվածքը հետևյալն է՝

array(5) {
  ["label"]=>
  string(16) "Maintenance mode"
  ["class"]=>
  string(34) "\Drupal\Core\Config\Schema\Mapping"
  ["definition_class"]=>
  string(40) "\Drupal\Core\TypedData\MapDataDefinition"
  ["mapping"]=>
  array(2) {
    ["langcode"]=>
    array(2) {
      ["type"]=>
      string(6) "string"
      ["label"]=>
      string(13) "Language code"
    }
    ["message"]=>
    array(2) {
      ["type"]=>
      string(4) "text"
      ["label"]=>
      string(43) "Message to display when in maintenance mode"
    }
  }
  ["type"]=>
  string(18) "system.maintenance"
}

Մի քիչ բարդ օրինակ՝ image.style.medium-ի առաջին էֆեկտի տիպավորված տվյալները ստանալու համար, ինչպես նշվեց վերևում՝

// Get typed configuration from under the the image.style.medium config 
// key's effects children. Take the uuid key shown above in the example config
// file (corresponding to the first effect in the style) and the data children's elements.
$effects = \Drupal::service('config.typed')->get('image.style.medium')->get('effects.bddf0d06-42f9-4c75-a700-a33cafa25ea0.data')->getDataDefinition();

Արդյունքում ստացվում է image.effect.image_scale տիպը, ինչպես նկարագրված է վերևում, և վերադարձվում է քարտեզի բնութագրում, օրինակ՝

object(Drupal\Core\TypedData\MapDataDefinition)#1061 (3) {
  ["mainPropertyName":protected]=>
  NULL
  ["propertyDefinitions":protected]=>
  NULL
  ["definition":protected]=>
  array(5) {
    ["type"]=>
    string(24) "image.effect.image_scale"
    ["label"]=>
    string(11) "Image scale"
    ["class"]=>
    string(34) "\Drupal\Core\Config\Schema\Mapping"
    ["definition_class"]=>
    string(40) "\Drupal\Core\TypedData\MapDataDefinition"
    ["mapping"]=>
    array(3) {
      ["width"]=>
      array(2) {
        ["type"]=>
        string(7) "integer"
        ["label"]=>
        string(5) "Width"
      }
      ["height"]=>
      array(2) {
        ["type"]=>
        string(7) "integer"
        ["label"]=>
        string(6) "Height"
      }
      ["upscale"]=>
      array(2) {
        ["type"]=>
        string(7) "boolean"
        ["label"]=>
        string(7) "Upscale"
      }
    }
  }
}

TypedData API-ն ամբողջությամբ կարող է օգտագործվել տարրերի հետ՝

// Get the effects sequence object from the medium image style.
$effects = \Drupal::service('config.typed')->get('image.style.medium')->get('effects');
// $effects represents the sequence keyed by uuids as shown above in the parent reference
// example. Use the getValue() TypedData method to retrieve the value.
$first_uuid = key($effects->getValue());
// Take the data keys for this first effect.
$data = $effects->get($first_uuid)->get('data');
// Examine values and types for width.
$data->get('width')->getPluginId(); // will return 'integer'
$data->get('width')->getValue(); // will return 220 

Տեսեք ավելի շատ օրինակներ կոնֆիգուրացիայի սխեմայով նավարկելու և ձևերի գեներացման համար՝ https://drupal.org/project/config_inspector

Ձեր սխեմայի ստուգում

Կոնֆիգուրացիայի ինսպեկտորի մոդուլը տրամադրում է UI սխեմաները համեմատելու և տեսնելու, թե ինչպես ձևերի գեներացիան աշխատում է տվյալների հետ։ Սա կարող է օգնել սխեմայի խնդիրների գտնումին։ Դիտեք https://drupal.org/node/1910624#comment-7088154՝ խորհրդատվության համար։

Կոնֆիգուրացիայի հիմնական թարգմանության մոդուլը իրական UI է ստեղծում սխեմաների վրա և թույլ է տալիս թարգմանել կոնֆիգուրացիան։ Կարող եք օգտագործել այն ստուգելու համար՝ արդյոք ձեր կոնֆիգուրացիան ճիշտ թարգմանվում է և թարգմանությունները ճիշտ տեղերում են հայտնվում։

Լրացուցիչ ռեսուրսներ

Դիտեք #1866610՝ Kwalify-ի ոճով սխեմայի ձևաչափի ներդնում, #1648930՝ կոնֆիգուրացիայի սխեմայի ներդնում և օգտագործում թարգմանության համար և #1914366՝ բոլոր կոնֆիգուրացիայի սխեմայի ֆայլերը schemas ենթաթողարկում։ Դրանք պատմում են այս սխեմայի ձևաչափի պատմությունը և զարգացումը։ Դիտեք նաև #1905152՝ կոնֆիգուրացիայի սխեմայի ինտեգրում՝ տեղական մոդուլի հետ և #1952394՝ կոնֆիգուրացիայի թարգմանության միջուկային մոդուլ։

#1602106՝ Դեֆոլտ կոնֆիգուրացիոն ֆայլերի փաստաթղթավորում՝ կոնֆիգուրացիայի YAML ֆայլերի կանոնների սկզբնավորման մասին։