YAML - Краткое руководство

YAML Ain't Markup Language - это язык сериализации данных, который соответствует ожиданиям пользователя в отношении данных. Он разработан для удобства людей и отлично работает с другими языками программирования. Это полезно для управления данными и включает печатные символы Unicode. В этой главе вы познакомитесь с YAML и познакомитесь с его функциями.

Формат

Рассмотрим текст, показанный ниже -

Quick brown fox jumped over the lazy dog.

Текст YAML для этого будет представлен, как показано ниже -

yaml.load(Quick brown fox jumped over the lazy dog.)
>>'Quick brown fox jumped over the lazy dog.'

Обратите внимание, что YAML принимает значение в строковом формате и представляет вывод, как указано выше.

Примеры

Давайте разберемся с форматами в YAML с помощью следующих примеров -

Рассмотрим следующий номер точки «пи», который имеет значение 3,1415926. В YAML он представлен как плавающее число, как показано ниже -

>>> yaml.load('3.1415926536')
3.1415926536

Предположим, несколько значений должны быть загружены в определенную структуру данных, как указано ниже -

eggs
ham
spam
French basil salmon terrine

Когда вы загружаете это в YAML, значения берутся в структуре данных массива, которая представляет собой форму списка. Результат показан ниже -

>>> yaml.load('''
   - eggs
   - ham
   - spam
   - French basil salmon terrine
   ''')
['eggs', 'ham', 'spam', 'French basil salmon terrine']

Особенности

YAML включает язык разметки с важной конструкцией, позволяющей отличать язык, ориентированный на данные, от разметки документа. Цели дизайна и особенности YAML приведены ниже -

• Соответствует собственным структурам данных гибкой методологии и ее языков, таких как Perl, Python, PHP, Ruby и JavaScript.

• Данные YAML переносимы между языками программирования

• Включает согласованную модель данных

• Легко читается людьми

• Поддерживает однонаправленную обработку

• Легкость внедрения и использования

Теперь, когда у вас есть представление о YAML и его функциях, давайте изучим его основы с синтаксисом и другими операциями. Помните, что YAML включает удобочитаемый структурированный формат.

Правила создания файла YAML

Когда вы создаете файл в YAML, вы должны помнить следующие основные правила:

• YAML чувствителен к регистру

• Файлы должны иметь .yaml как расширение

• YAML не позволяет использовать вкладки при создании файлов YAML; вместо этого разрешены пробелы

Основные компоненты файла YAML

Основные компоненты YAML описаны ниже -

Обычный формат блока

Этот формат блока использует hyphen+spaceчтобы начать новый элемент в указанном списке. Обратите внимание на пример, показанный ниже -

--- # Favorite movies
 - Casablanca
 - North by Northwest
 - The Man Who Wasn't There

Inline Format

Встроенный формат ограничен comma and spaceи элементы заключены в JSON. Обратите внимание на пример, показанный ниже -

--- # Shopping list
   [milk, groceries, eggs, juice, fruits]

Folded Text

Сложенный текст преобразует новые строки в пробелы и удаляет начальные пробелы. Обратите внимание на пример, показанный ниже -

- {name: John Smith, age: 33}
- name: Mary Smith
  age: 27

Структура, которая следует всем основным соглашениям YAML, показана ниже -

men: [John Smith, Bill Jones]
women:
  - Mary Smith
  - Susan Williams

Сводка базовых элементов YAML

• Краткое описание основных элементов YAML приведено здесь: Комментарии в YAML начинаются с символа (#) персонаж.

• Комментарии должны быть отделены от других токенов пробелами.

• Отступ пробелов используется для обозначения структуры.

• Вкладки не включены в качестве отступов для файлов YAML.

• Члены списка обозначаются ведущим дефисом (-).

• Члены списка заключаются в квадратные скобки и разделяются запятыми.

• Ассоциативные массивы представлены двоеточием ( : )в формате пары ключ-значение. Они заключены в фигурные скобки.{}.

• Несколько документов с одним потоком разделяются тремя дефисами (---).

• Повторяющиеся узлы в каждом файле изначально обозначаются амперсандом (&) и звездочкой (*) отметим позже.

• YAML всегда требует использования двоеточий и запятых в качестве разделителей списков, за которыми следует пробел со скалярными значениями.

• Узлы должны быть помечены восклицательным знаком (!) или двойным восклицательным знаком (!!), за которым следует строка, которая может быть расширена в URI или URL.

Отступы и разделение - две основные концепции, когда вы изучаете любой язык программирования. В этой главе подробно рассказывается об этих двух концепциях, связанных с YAML.

Отступ YAML

YAML не содержит обязательных пробелов. Кроме того, нет необходимости быть последовательным. Действительный отступ YAML показан ниже -

a:
   b:
      - c
      -  d
      - e
f:
      "ghi"

• Вы должны помнить следующие правила при работе с отступом в YAML: Блоки потока должны иметь хотя бы некоторые пробелы, окружающие текущий уровень блока.

• Содержимое потока YAML занимает несколько строк. Начало потока содержимого начинается с{ или же [.

• Элементы списка блокировки включают тот же отступ, что и уровень окружающего блока, потому что - считается частью отступа.

Пример предполагаемого блока

Обратите внимание на следующий код, который показывает отступы с примерами -

--- !clarkevans.com/^invoice
invoice: 34843
date   : 2001-01-23
bill-to: &id001
   given  : Chris
   family : Dumars
   address:
      lines: |
            458 Walkman Dr.
            Suite #292
      city    : Royal Oak
      state   : MI
      postal  : 48046
ship-to: *id001
product:
    - sku         : BL394D
      quantity    : 4
      description : Basketball
      price       : 450.00
   - sku         : BL4438H
      quantity    : 1
      description : Super Hoop
      price       : 2392.00
tax  : 251.42
total: 4443.52
comments: >
    Late afternoon is best.
    Backup contact is Nancy
    Billsmer @ 338-4338.

Разделение строк

Строки разделяются строками в двойных кавычках. Если вы экранируете символы новой строки в данной строке, она полностью удаляется и переводится в значение пробела.

пример

В этом примере мы сфокусировали список животных, перечисленных как структура массива с типом данных строки. Каждый новый элемент перечисляется с префиксом дефиса, который упоминается как префикс.

-
 - Cat
 - Dog
 - Goldfish
-
 - Python
 - Lion
 - Tiger

Другой пример для объяснения строкового представления в YAML упомянут ниже.

errors:
      messages:
         already_confirmed: "was already confirmed, please try signing in"
         confirmation_period_expired: "needs to be confirmed within %{period}, please request a new one"
         expired: "has expired, please request a new one"
         not_found: "not found"
         not_locked: "was not locked"
         not_saved:
            one: "1 error prohibited this %{resource} from being saved:"
            other: "%{count} errors prohibited this %{resource} from being saved:"

Этот пример относится к набору сообщений об ошибках, которые пользователь может использовать, просто упомянув ключевой аспект и получив соответствующие значения. Этот шаблон YAML следует структуре JSON, которую может понять пользователь, который плохо знаком с YAML.

Теперь, когда вы знакомы с синтаксисом и основами YAML, давайте перейдем к его деталям. В этой главе мы увидим, как использовать комментарии в YAML.

YAML supports single line comments. Его структура объясняется ниже с помощью примера -

# this is single line comment.

YAML does not support multi line comments. Если вы хотите предоставить комментарии для нескольких строк, вы можете сделать это, как показано в примере ниже -

# this
# is a multiple
# line comment

Особенности комментариев

Особенности комментариев в YAML приведены ниже -

• Прокомментированный блок пропускается во время выполнения.

• Комментарии помогают добавить описание для указанного блока кода.

• Комментарии не должны появляться внутри скаляров.

• YAML не включает никакого способа избежать символа решетки (#) внутри многострочной строки, поэтому нет возможности отделить комментарий от необработанного строкового значения.

Комментарии в коллекции показаны ниже -

key: #comment 1
   - value line 1
   #comment 2
   - value line 2
   #comment 3
   - value line 3

Комбинация горячих клавиш для комментирования блоков YAML: Ctrl+Q.

Если вы используете Sublime Text editor, шаги для комментирования блока упомянуты ниже -

Выберите блок. Используйте «CTRL + /» в Linux и Windows и «CMD + /» в операционной системе Mac. Выполните блок.

Обратите внимание, что те же шаги применимы, если вы используете Visual Studio Code Editor. Всегда рекомендуется использоватьSublime Text Editor для создания файлов YAML, поскольку он поддерживается большинством операционных систем и включает удобные для разработчиков сочетания клавиш.

YAML включает коллекции блоков, которые используют отступы для области видимости. Здесь каждая запись начинается с новой строки. Последовательности блоков в коллекциях обозначают каждую запись значкомdash and space(-). В YAML стили коллекций блоков не обозначаются каким-либо конкретным индикатором. Коллекцию блоков в YAML можно отличить от других скалярных величин с помощью идентификации пары ключ-значение, включенной в них.

Сопоставления - это представление значения ключа, включенного в структуру JSON. Часто используется в многоязычных системах поддержки и создании API в мобильных приложениях. Отображения используют представление пары ключ-значение с использованиемcolon and space (:).

Примеры

Рассмотрим пример последовательности скаляров, например список игроков в мяч, как показано ниже -

- Mark Joseph
- James Stephen
- Ken Griffey

В следующем примере показано отображение скаляров на скаляры -

hr: 87
avg: 0.298
rbi: 149

В следующем примере показано сопоставление скаляров последовательностям -

European:
- Boston Red Sox
- Detroit Tigers
- New York Yankees

national:
- New York Mets
- Chicago Cubs
- Atlanta Braves

Коллекции могут использоваться для сопоставлений последовательностей, которые показаны ниже -

-
   name: Mark Joseph
   hr: 87
   avg: 0.278
-
   name: James Stephen
   hr: 63
   avg: 0.288

В коллекциях YAML включает стили потока с использованием явных индикаторов вместо использования отступов для обозначения пространства. Последовательность потоков в коллекциях записывается в виде списка, разделенного запятыми, заключенного в квадратные скобки. Лучшая иллюстрация для коллекции, которая включена в фреймворки PHP, такие как symphony.

[PHP, Perl, Python]

Эти коллекции хранятся в документах. Разделение документов в YAML обозначается тремя дефисами или тире (---). Конец документа отмечен тремя точками (…).

Разделение документов в YAML обозначается тремя дефисами (---). Конец документа представлен тремя точками (…).

Представление документа упоминается как формат структуры, который упоминается ниже -

# Ranking of 1998 home runs
---
- Mark Joseph
- James Stephen
- Ken Griffey 

# Team ranking
---
- Chicago Cubs
- St Louis Cardinals

Знак вопроса с комбинацией пробелов указывает на сложное отображение структуры. В коллекцию блоков пользователь может включить структуру с тире, двоеточием и вопросительным знаком. В следующем примере показано сопоставление между последовательностями -

- 2001-07-23
? [ New York Yankees,Atlanta Braves ]
: [ 2001-07-02, 2001-08-12, 2001-08-14]

Скаляры в YAML записываются в блочном формате с использованием буквального типа, который обозначается как (|). Он обозначает количество разрывов строк. В YAML скаляры записываются в свернутом виде (>), где каждая линия обозначает сложенное пространство, которое заканчивается empty line или же more indented линия.

Новые строки сохраняются в литералах, как показано ниже -

ASCII Art
--- |
\//||\/||
// || ||__

Свернутые символы новой строки сохраняются для more indented lines и blank lines как показано ниже -

>
Sammy Sosa completed another
fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!

Скаляры потока YAML включают простые стили и стили в кавычках. Стиль двойных кавычек включает в себя различные escape-последовательности. Скаляры потока могут включать несколько строк; разрывы строк в этой структуре всегда складываются.

plain:
This unquoted scalar
spans many lines.
quoted: "So does this
quoted scalar.\n"

В YAML немаркированные узлы указываются с конкретным типом приложения. В примерах спецификации тегов обычно используетсяseq, map и strтипы для репозитория тегов YAML. Теги представлены в виде примеров, которые указаны ниже -

Целочисленные теги

Эти теги включают в себя целые числа. Их также называют числовыми тегами.

canonical: 12345
decimal: +12,345
sexagecimal: 3:25:45
octal: 014
hexadecimal: 0xC

Числа с плавающей запятой

Эти теги включают десятичные и экспоненциальные значения. Их также называют экспоненциальными тегами.

canonical: 1.23015e+3
exponential: 12.3015e+02
sexagecimal: 20:30.15
fixed: 1,230.15
negative infinity: -.inf
not a number: .NaN

Разные теги

Он включает в себя множество встроенных в них целочисленных, плавающих и строковых значений. Отсюда и название разных тегов.

null: ~
true: y
false: n
string: '12345'

В следующем полномасштабном примере описывается конструкция YAML, которая включает символы и различные представления, которые будут полезны при их преобразовании или обработке в формате JSON. Эти атрибуты также называются ключевыми именами в документах JSON. Эти обозначения созданы в целях безопасности.

Вышеупомянутый формат YAML представляет различные атрибуты значений по умолчанию, адаптера и хоста с различными другими атрибутами. YAML также ведет журнал каждого сгенерированного файла, в котором отслеживаются сгенерированные сообщения об ошибках. При преобразовании указанного файла YAML в формат JSON мы получаем желаемый результат, как указано ниже -

defaults: &defaults
   adapter:  postgres
   host:     localhost

development:
   database: myapp_development
   <<: *defaults

test:
   database: myapp_test
   <<: *defaults

Давайте преобразуем YAML в формат JSON и проверим вывод.

{
   "defaults": {
      "adapter": "postgres",
      "host": "localhost"
   },
   "development": {
      "database": "myapp_development",
      "adapter": "postgres",
      "host": "localhost"
   },
   "test": {
      "database": "myapp_test",
      "adapter": "postgres",
      "host": "localhost"
   }
}

Ключ по умолчанию с префиксом «<<: *» включается по мере необходимости, без необходимости повторять один и тот же фрагмент кода.

YAML следует стандартной процедуре для потока операций. Собственная структура данных в YAML включает простые представления, такие как узлы. Его также называют графом узлов представления.

Он включает отображение, последовательность и скалярные величины, которые сериализуются для создания дерева сериализации. При сериализации объекты преобразуются потоком байтов.

Дерево событий сериализации помогает в создании представления символьных потоков, как показано на следующей диаграмме.

Обратная процедура анализирует поток байтов в сериализованное дерево событий. Позже узлы преобразуются в граф узлов. Эти значения позже преобразуются в собственную структуру данных YAML. Рисунок ниже объясняет это -

Информация в YAML используется двумя способами: machine processing и human consumption. Процессор в YAML используется как инструмент для процедуры преобразования информации между дополнительными представлениями на диаграмме, приведенной выше. В этой главе описываются информационные структуры, которые процессор YAML должен предоставлять в данном приложении.

YAML включает процедуру сериализации для представления объектов данных в последовательном формате. Обработка информации YAML включает три этапа:Representation, Serialization, Presentation and parsing. Обсудим подробно каждый из них.

Представление

YAML представляет структуру данных с использованием узлов трех типов: sequence, mapping и scalar.

Последовательность

Последовательность относится к упорядоченному количеству записей, которое отображает неупорядоченную ассоциацию пары ключ-значение. Он соответствует списку массивов Perl или Python.

Код, показанный ниже, является примером представления последовательности -

product:
   - sku         : BL394D
     quantity    : 4
     description : Football
     price       : 450.00
   - sku         : BL4438H
     quantity    : 1
     description : Super Hoop
     price       : 2392.00

Картография

С другой стороны, отображение представляет собой структуру данных словаря или хеш-таблицу. Пример того же упомянут ниже -

batchLimit: 1000
threadCountLimit: 2
key: value
keyMapping: <What goes here?>

Скаляры

Скаляры представляют собой стандартные значения строк, целых чисел, дат и атомарных типов данных. Обратите внимание, что YAML также включает узлы, которые определяют структуру типа данных. Дополнительную информацию о скалярах см. В главе 6 этого руководства.

Сериализация

В YAML требуется процесс сериализации, который упрощает понятный для человека порядок ключей и имена привязок. Результатом сериализации является дерево сериализации YAML. Его можно пройти, чтобы произвести серию вызовов событий данных YAML.

Пример для сериализации приведен ниже -

consumer:
   class: 'AppBundle\Entity\consumer'
   attributes:
      filters: ['customer.search', 'customer.order', 'customer.boolean']
   collectionOperations:
      get:
         method: 'GET'
         normalization_context:
       groups: ['customer_list']
   itemOperations:
      get:
         method: 'GET'
         normalization_context:
            groups: ['customer_get']

Презентация

Окончательный результат сериализации YAML называется презентацией. Он представляет собой поток символов в дружественной к человеку манере. Процессор YAML включает в себя различные детали представления для создания потока, обработки отступов и форматирования содержимого. Этот полный процесс определяется предпочтениями пользователя.

Примером процесса представления YAML является результат созданного значения JSON. Обратите внимание на код, приведенный ниже, для лучшего понимания -

{
   "consumer": {
      "class": "AppBundle\\Entity\\consumer",
      "attributes": {
         "filters": [
            "customer.search",
            "customer.order",
            "customer.boolean"
         ]
      },
      "collectionOperations": {
         "get": {
            "method": "GET",
            "normalization_context": {
               "groups": [
                  "customer_list"
               ]
            }
         }
      },
      "itemOperations": {
         "get": {
            "method": "GET",
            "normalization_context": {
               "groups": [
                  "customer_get"
               ]
            }
         }
      }
   }
}

Парсинг

Парсинг - это обратный процесс представления; он включает в себя поток персонажей и создает серию событий. Он отбрасывает детали, представленные в процессе представления, который вызывает события сериализации. Процедура синтаксического анализа может завершиться ошибкой из-за неверного ввода По сути, это процедура проверки правильности формирования YAML.

Рассмотрим пример YAML, который упомянут ниже -

---
   environment: production
   classes:
      nfs::server:
         exports:
            - /srv/share1
            - /srv/share3
   parameters:
      paramter1

С тремя дефисами он представляет начало документа с различными атрибутами, определенными в нем позже.

YAML lint - это онлайн-анализатор YAML, который помогает анализировать структуру YAML, чтобы проверить, действительна она или нет. Официальная ссылка на YAML lint указана ниже:http://www.yamllint.com/

Вы можете увидеть результат синтаксического анализа, как показано ниже -

В этой главе будут подробно описаны процедуры и процессы, которые мы обсуждали в предыдущей главе. Информационные модели в YAML будут определять особенности процедуры сериализации и представления в систематическом формате с использованием конкретной диаграммы.

Для информационной модели важно представлять информацию о приложении, которая переносима между средами программирования.

Диаграмма, показанная выше, представляет собой обычную информационную модель, которая представлена ​​в графическом формате. В YAML представление собственных данных является корневым, связанным и представляет собой ориентированный граф помеченных узлов. Если мы упоминаем ориентированный граф, он включает в себя набор узлов с ориентированным графом. Как упоминалось в информационной модели, YAML поддерживает три типа узлов, а именно:

• Sequences
• Scalars
• Mappings

Основные определения этих узлов представления обсуждались в предыдущей главе. В этой главе мы сосредоточимся на схематическом представлении этих терминов. Следующая диаграмма последовательности представляет рабочий процесс легенд с различными типами тегов и узлов сопоставления.

Есть три типа узлов: sequence node, scalar node и mapping node.

Последовательности

Узел Sequence следует последовательной архитектуре и включает упорядоченную серию из нуля или более узлов. Последовательность YAML может содержать один и тот же узел несколько раз или один узел.

Скаляры

Содержимое скаляров в YAML включает символы Unicode, которые могут быть представлены в формате с серией нулей. В общем, скалярный узел включает скалярные величины.

Картография

Узел сопоставления включает представление пары ключ-значение. Содержимое узла сопоставления включает комбинацию пары «ключ-значение» с обязательным условием сохранения уникальности имени ключа. Последовательности и сопоставления вместе образуют коллекцию.

Обратите внимание, что, как показано на схеме, показанной выше, скаляры, последовательности и сопоставления представлены в систематическом формате.

Различные типы символов используются для различных функций. В этой главе подробно рассказывается о синтаксисе, используемом в YAML, и основное внимание уделяется манипулированию символами.

Индикаторные символы

Символы индикатора включают особую семантику, используемую для описания содержимого документа YAML. В следующей таблице это подробно показано.

Sr.No.	Характер и функциональность
1	_ Он обозначает запись последовательности блоков
2	? Он обозначает ключ отображения
3	: Он обозначает значение отображения
4	, Обозначает запись коллекции потока
5	[ Запускает последовательность операций
6	] Завершает последовательность операций
7	{ Он запускает отображение потока
8	} Это завершает отображение потока
9	# Он обозначает комментарии
10	& Он обозначает свойство привязки узла
11	* Он обозначает узел псевдонима
12	! Обозначает тег узла
13	| Он обозначает буквальный скаляр блока
14	> Он обозначает скаляр из свернутого блока
15	` Одиночная кавычка окружает цитируемый скаляр потока
16	" Двойные кавычки окружают скаляр потока в двойных кавычках
17	% Он обозначает используемую директиву

В следующем примере показаны символы, используемые в синтаксисе -

%YAML 1.1
---
!!map {
   ? !!str "sequence"
   : !!seq [
      !!str "one", !!str "two"
   ],
   ? !!str "mapping"
   : !!map {
      ? !!str "sky" : !!str "blue",
      ? !!str "sea" : !!str "green",
   }
}

# This represents
# only comments.
---
!!map1 {
   ? !!str "anchored"
   : !local &A1 "value",
   ? !!str "alias"
   : *A1,
}
!!str "text"

В этой главе вы узнаете о следующих аспектах синтаксических примитивов в YAML:

• Параметры производства
• Отступы
• Разделительные пространства
• Игнорируемый префикс строки
• Сгибание линий

Давайте разберемся в каждом аспекте подробно.

Параметры производства

Производственные параметры включают в себя набор параметров и диапазон допустимых значений, которые используются на конкретном производстве. Следующий список производственных параметров используется в YAML -

Отступ

Обозначается символом n или же mПоток символов зависит от уровня отступов входящих в него блоков. Многие производства параметризовали эти функции.

Контекст

Обозначается он c. YAML поддерживает две группы контекстов:block styles и flow styles.

Стиль

Обозначается буквой s. Скалярное содержимое может быть представлено в одном из пяти стилей:plain, double quoted and single quoted flow, literal and folded block.

Чавканье

Обозначается он t. Блочные скаляры предлагают множество механизмов, которые помогают обрезать блок:strip, clip и keep. Chomping помогает форматировать новые строки строк. Используется блочное представление стиля. Процесс жевания происходит с помощью индикаторов. Индикаторы контролируют, какой вывод должен производиться с новой строкой строки. Новые строки удаляются с помощью(-) оператор и новые строки добавляются с помощью (+) оператор.

Пример процесса пережевывания показан ниже -

strip: |-
   text↓
clip: |
   text↓
keep: |+
   text↓

Результат после анализа указанного примера YAML выглядит следующим образом:

Отступы

В потоке символов YAML отступ определяется как символ разрыва строки на ноль или более символов. Самым важным моментом, который следует иметь в виду, является то, что отступ не должен содержать никаких символов табуляции. Символы в отступе никогда не следует рассматривать как часть информации о содержимом узла. Обратите внимание на следующий код для лучшего понимания -

%YAML 1.1
---
!!map {
   ? !!str "Not indented"
   : !!map {
      ? !!str "By one space"
      : !!str "By four\n spaces\n",
      ? !!str "Flow style"
      : !!seq [
         !!str "By two",
         !!str "Still by two",
         !!str "Again by two",
      ]
   }
}

Результат, который вы можете увидеть после отступа, выглядит следующим образом:

{
   "Not indented": {
      "By one space": "By four\n spaces\n", 
      "Flow style": [
         "By two", 
         "Still by two", 
         "Again by two"
      ]
   }
}

Разделительные пространства

YAML использует пробелы для разделения токенов. Самое важное замечание: разделение в YAML не должно содержать символов табуляции.

Следующий фрагмент кода показывает использование разделительных пространств -

{ · first: · Sammy, · last: · Sosa · }

{
   "\u00b7 last": "\u00b7 Sosa \u00b7", 
   "\u00b7 first": "\u00b7 Sammy"
}

Игнорируемый префикс строки

Пустой префикс всегда включает отступ в зависимости от скалярного типа, который также включает начальные пробелы. Простые скаляры не должны содержать символов табуляции. С другой стороны, скаляры в кавычках могут содержать символы табуляции. Блочные скаляры полностью зависят от отступа.

Следующий пример показывает систематическую работу игнорируемого префикса строки -

%YAML 1.1
---
!!map {
   ? !!str "plain"
   : !!str "text lines",
   ? !!str "quoted"
   : !!str "text lines",
   ? !!str "block"
   : !!str "text·®lines\n"
}

Результат, достигнутый для блочных потоков, выглядит следующим образом:

{
   "plain": "text lines", 
   "quoted": "text lines", 
   "block": "text\u00b7\u00aelines\n"
}

Складывание линии

Сгибание строк позволяет разбивать длинные строки для удобства чтения. Чем больше короткие строки, тем лучше читаемость. Сворачивание строк достигается за счет учета исходной семантики длинной строки. В следующем примере демонстрируется перенос строк -

%YAML 1.1
--- !!str
"specific\L\
trimmed\n\n\n\
as space"

Вы можете увидеть вывод для переноса строк в формате JSON следующим образом:

"specific\u2028trimmed\n\n\nas space"

В YAML вы сталкиваетесь с различными потоками символов следующим образом:

• Directives
• Маркеры границ документа
• Documents
• Полный поток

В этой главе мы обсудим их подробно.

Директивы

Директивы - это основные инструкции, используемые в процессоре YAML. Директивы - это детали представления, такие как комментарии, которые не отражаются в дереве сериализации. В YAML нет способа определить частные директивы. В этом разделе обсуждаются различные типы директив с соответствующими примерами -

Зарезервированные директивы

Зарезервированные директивы инициализируются тремя символами дефиса (---), как показано в примере ниже. Зарезервированные директивы преобразуются в конкретное значение JSON.

%YAML 1.1
--- !!str
"foo"

Директива YAML

Директивы YAML - это директивы по умолчанию. Если преобразовано в JSON, полученное значение включает символ прямой косой черты в предшествующих и завершающих символах.

%YAML 1.1
---
!!str "foo"

Маркеры границ документа

YAML использует эти маркеры, чтобы позволить более чем одному документу содержаться в одном потоке. Эти маркеры специально используются для передачи структуры документа YAML. Обратите внимание, что строка, начинающаяся с «---», используется для начала нового документа.

Следующий код объясняет это с примерами -

%YAML 1.1
---
!!str "foo"
%YAML 1.1
---
!!str "bar"
%YAML 1.1
---
!!str "baz"

Документы

Документ YAML рассматривается как единственная собственная структура данных, представленная как единственный корневой узел. Детали представления в документе YAML, такие как директивы, комментарии, отступы и стили, не рассматриваются как включенное в них содержимое.

В YAML используются два типа документов. Они объясняются в этом разделе -

Явные документы

Он начинается с маркера начала документа, за которым следует представление корневого узла. Пример явного объявления YAML приведен ниже -

---

some: yaml

...

Он включает явные маркеры начала и конца, которые в данном примере - «---» и «…». При преобразовании указанного YAML в формат JSON мы получаем вывод, как показано ниже -

{
   "some": "yaml"
}

Неявные документы

Эти документы не начинаются с маркера начала документа. Соблюдайте код, приведенный ниже -

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

Преобразуя эти значения в формат JSON, мы получаем результат в виде простого объекта JSON, как показано ниже -

{
   "fruits": [
      "Apple",
      "Orange",
      "Pineapple",
      "Mango"
   ]
}

Полный поток

YAML включает последовательность байтов, называемую потоком символов. Поток начинается с префикса, содержащего порядок байтов, обозначающий кодировку символов. Полный поток начинается с префикса, содержащего кодировку символов, за которым следуют комментарии.

Пример полного потока (потока символов) показан ниже -

%YAML 1.1
---
!!str "Text content\n"

Каждый узел представления включает две основные характеристики, называемые anchor и tag. Свойства узла могут быть указаны с содержимым узла, исключенным из потока символов.

Базовый пример представления узла выглядит следующим образом:

%YAML 1.1
---
!!map {
   ? &A1 !!str "foo"
   : !!str "bar",
   ? !!str &A2 "baz"
   : *a1
}

Якоря узлов

Свойство привязки представляет собой узел для использования в будущем. Символьный поток представления YAML в узле обозначаетсяampersand (&)индикатор. Процессору YAML не нужно сохранять имя привязки с составленными в нем деталями представления. Следующий код объясняет это -

%YAML 1.1
---
!!map {
   ? !!str "First occurence"
   : &A !!str "Value",
   ? !!str "Second occurence"
   : *A
}

Вывод YAML, созданный с помощью узлов привязки, показан ниже -

---
!!map {
   ? !!str "First occurence"
   : !!str "Value",
   ? !!str "Second occurence"
   : !!str "Value",
}

Теги узла

Свойство tag представляет тип собственной структуры данных, которая полностью определяет узел. Тег представлен с помощью (!) индикатор. Теги рассматриваются как неотъемлемая часть графа представления. В следующем примере подробно объясняются теги узлов -

%YAML 1.1
---
!!map {
   ? !<tag:yaml.org,2002:str> "foo"
   : !<!bar> "baz"
}

Содержимое узла

Содержимое узла может быть представлено в виде содержимого потока или в формате блока. Содержимое блока простирается до конца строки и использует отступ для обозначения структуры. Каждый тип коллекции может быть представлен в отдельном стиле коллекции потока или может рассматриваться как единый блок. Следующий код подробно объясняет это -

%YAML 1.1
---
!!map {
   ? !!str "foo"
   : !!str "bar baz"
}

%YAML 1.1
---
!!str "foo bar"

%YAML 1.1
---
!!str "foo bar"

%YAML 1.1
---
!!str "foo bar\n"

В этой главе мы сосредоточимся на различных скалярных типах, которые используются для представления контента. В YAML комментарии могут предшествовать или следовать за скалярным содержимым. Важно отметить, что комментарии не следует включать в скалярное содержимое.

Обратите внимание, что все скалярные стили потока могут включать несколько строк, за исключением использования нескольких ключей.

Представление скаляров приведено ниже -

%YAML 1.1
---
!!map {
   ? !!str "simple key"
   : !!map {
      ? !!str "also simple"
      : !!str "value",
      ? !!str "not a simple key"
      : !!str "any value"
   }
}

Сгенерированный вывод скалярных заголовков блока показан ниже -

{
   "simple key": {
      "not a simple key": "any value", 
      "also simple": "value"
   }
}

Скалярное содержимое маркера документа

Все символы в этом примере считаются содержимым, включая символы внутреннего пространства.

%YAML 1.1
---
!!map {
   ? !!str "---"
   : !!str "foo",
   ? !!str "...",
   : !!str "bar"
}

%YAML 1.1
---
!!seq [
   !!str "---",
   !!str "...",
   !!map {
      ? !!str "---"
      : !!str "..."
   }
]

Простые разрывы строк представлены в примере, приведенном ниже -

%YAML 1.1
---
!!str "as space \
trimmed\n\
specific\L\n\
none"

Соответствующий вывод JSON для этого же упомянут ниже -

"as space trimmed\nspecific\u2028\nnone"

Стили потока в YAML можно рассматривать как естественное расширение JSON, охватывающее складывающиеся строки содержимого для более удобочитаемой функции, которая использует якоря и псевдонимы для создания экземпляров объектов. В этой главе мы сосредоточимся на потоковом представлении следующих понятий:

• Узлы псевдонима
• Пустые узлы
• Скалярные стили потока
• Стили коллекции Flow
• Узлы потока

Пример узлов псевдонима показан ниже -

%YAML 1.2
---
!!map {
   ? !!str "First occurrence"
   : &A !!str "Foo",
   ? !!str "Override anchor"
   : &B !!str "Bar",
   ? !!str "Second occurrence"
   : *A,
   ? !!str "Reuse anchor"
   : *B,
}

Вывод JSON приведенного выше кода приведен ниже -

{
   "First occurrence": "Foo", 
   "Second occurrence": "Foo", 
   "Override anchor": "Bar", 
   "Reuse anchor": "Bar"
}

Узлы с пустым содержимым считаются пустыми узлами. Следующий пример показывает это -

%YAML 1.2
---
!!map {
   ? !!str "foo" : !!str "",
   ? !!str "" : !!str "bar",
}

Вывод пустых узлов в JSON представлен ниже -

{
   "": "bar", 
   "foo": ""
}

Стили скалярного потока включают двойные кавычки, одиночные кавычки и простые типы. Базовый пример того же приведен ниже -

%YAML 1.2
---
!!map {
   ? !!str "implicit block key"
   : !!seq [
      !!map {
         ? !!str "implicit flow key"
         : !!str "value",
      }
   ]  
}

Вывод в формате JSON для приведенного выше примера показан ниже -

{
   "implicit block key": [
      {
         "implicit flow key": "value"
      }
   ] 
}

Коллекция потоков в YAML вложена в коллекцию блоков в другую коллекцию потоков. Записи коллекции потока завершаютсяcomma (,) индикатор. В следующем примере подробно объясняется блок сбора потока -

%YAML 1.2
---
!!seq [
   !!seq [
      !!str "one",
      !!str "two",
   ],
   
   !!seq [
      !!str "three",
      !!str "four",
   ],
]

Вывод для сбора потока в JSON показан ниже -

[
   [
      "one", 
      "two"
   ], 
   [
      "three", 
      "four"
   ]
]

Стили потока, такие как JSON, включают индикаторы начала и конца. Единственный стиль потока, который не имеет никаких свойств, - это простой скаляр.

%YAML 1.2
---
!!seq [
!!seq [ !!str "a", !!str "b" ],
!!map { ? !!str "a" : !!str "b" },
!!str "a",
!!str "b",
!!str "c",]

Вывод для показанного выше кода в формате JSON приведен ниже -

[
   [
      "a", 
      "b"
   ], 
   
   {
      "a": "b"
   }, 
   
   "a", 
   "b", 
   "c"
]

YAML включает два блочных скалярных стиля: literal и folded. Блочные скаляры контролируются несколькими индикаторами с заголовком, предшествующим самому содержимому. Пример блочных скалярных заголовков приведен ниже -

%YAML 1.2
---
!!seq [
   !!str "literal\n",
   !!str "·folded\n",
   !!str "keep\n\n",
   !!str "·strip",
]

Вывод в формате JSON с поведением по умолчанию приведен ниже -

[
   "literal\n", 
   "\u00b7folded\n", 
   "keep\n\n", 
   "\u00b7strip"
]

Типы стилей блоков

Есть четыре типа стилей блоков: literal, folded, keep и stripстили. Эти стили блоков определяются с помощью сценария Block Chomping. Пример сценария пережевывания блока приведен ниже -

%YAML 1.2
---
!!map {
   ? !!str "strip"
   : !!str "# text",
   ? !!str "clip"
   : !!str "# text\n",
   ? !!str "keep"
   : !!str "# text\n",
}

Вы можете увидеть результат, сгенерированный в трех форматах в JSON, как показано ниже -

{
   "strip": "# text", 
   "clip": "# text\n", 
   "keep": "# text\n"
}

Chomping в YAML контролирует окончательные разрывы и завершающие пустые строки, которые интерпретируются в различных формах.

Зачистка

В этом случае последний разрыв строки и пустые строки исключаются для скалярного содержимого. Об этом свидетельствует индикатор «-».

Вырезка

Отсечение считается поведением по умолчанию, если не указан явный индикатор пережевывания. Последний символ разрыва сохраняется в содержимом скаляра. Лучший пример отсечения показан в примере выше. Он заканчивается новой строкой“\n” персонаж.

Сохранение

Сохранение относится к добавлению с отображением индикатора «+». Созданные дополнительные линии не подлежат складыванию. Дополнительные строчки складыванию не подлежат.

Чтобы понять стили последовательности, важно понимать коллекции. Концепция коллекций и стили последовательности работают параллельно. Коллекция в YAML представлена ​​соответствующими стилями последовательности. Если вы хотите указать правильную последовательность тегов, всегда обращайтесь к коллекциям. Коллекции в YAML индексируются последовательными целыми числами, начиная с нуля, как представлено в массивах. Фокус стилей последовательности начинается с коллекций.

пример

Давайте рассмотрим количество планет во Вселенной как последовательность, которую можно создать как совокупность. В следующем коде показано, как представить стили последовательности планет во вселенной.

# Ordered sequence of nodes in YAML STRUCTURE
Block style: !!seq
- Mercury   # Rotates - no light/dark sides.
- Venus     # Deadliest. Aptly named.
- Earth     # Mostly dirt.
- Mars      # Seems empty.
- Jupiter   # The king.
- Saturn    # Pretty.
- Uranus    # Where the sun hardly shines.
- Neptune   # Boring. No rings.
- Pluto     # You call this a planet?
Flow style: !!seq [ Mercury, Venus, Earth, Mars,      # Rocks
                    Jupiter, Saturn, Uranus, Neptune, # Gas
                    Pluto ]                           # Overrated

Затем вы можете увидеть следующий вывод для упорядоченной последовательности в формате JSON -

{
   "Flow style": [
      "Mercury", 
      "Venus", 
      "Earth", 
      "Mars", 
      "Jupiter", 
      "Saturn", 
      "Uranus", 
      "Neptune", 
      "Pluto"
   ], 
   
   "Block style": [
      "Mercury", 
      "Venus", 
      "Earth", 
      "Mars", 
      "Jupiter", 
      "Saturn", 
      "Uranus", 
      "Neptune", 
      "Pluto"
   ]
}

Отображения потоков в YAML представляют собой неупорядоченный набор пар ключ-значение. Их также называют узлами отображения. Обратите внимание, что ключи должны быть уникальными. Если есть дублирование ключей в структуре отображения потока, это вызовет ошибку. Порядок ключей создается в дереве сериализации.

пример

Пример структуры отображения потока показан ниже -

%YAML 1.1
paper:
   uuid: 8a8cbf60-e067-11e3-8b68-0800200c9a66
   name: On formally undecidable propositions of  Principia Mathematica and related systems I.
   author: Kurt Gödel.
tags:
   - tag:
      uuid: 98fb0d90-e067-11e3-8b68-0800200c9a66
      name: Mathematics
   - tag:
      uuid: 3f25f680-e068-11e3-8b68-0800200c9a66
      name: Logic

Вывод сопоставленной последовательности (неупорядоченный список) в формате JSON показан ниже -

{
   "paper": {
      "uuid": "8a8cbf60-e067-11e3-8b68-0800200c9a66",
      "name": "On formally undecidable propositions of Principia Mathematica and related systems I.",
      "author": "Kurt Gödel."
   },
   "tags": [
      {
         "tag": {
            "uuid": "98fb0d90-e067-11e3-8b68-0800200c9a66",
            "name": "Mathematics"
         }
      },
      {
         "tag": {
            "uuid": "3f25f680-e068-11e3-8b68-0800200c9a66",
            "name": "Logic"
         }
      }
   ]
}

Если вы наблюдаете этот вывод, как показано выше, можно заметить, что имена ключей сохраняются уникальными в структуре отображения YAML.

Последовательности блоков YAML представляют собой серию узлов. Каждый элемент обозначается ведущим индикатором «-». Обратите внимание, что индикатор «-» в YAML должен быть отделен от узла пробелом.

Базовое представление последовательности блоков приведено ниже -

block sequence:
··- one↓
  - two : three↓

пример

Обратите внимание на следующие примеры, чтобы лучше понять последовательность блоков.

Пример 1

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

Вывод последовательностей блоков в формате JSON приведен ниже -

{
   "port": {
      "adapter": "postgres",
      "host": "localhost"
   },
   "development": {
      "database": "myapp_development",
      "adapter": "postgres",
      "host": "localhost"
   }
}

Схема YAML определяется как комбинация набора тегов и включает механизм для разрешения неспецифических тегов. Отказоустойчивая схема в YAML создается таким образом, что ее можно использовать с любым документом YAML. Это также считается рекомендуемой схемой для общего документа YAML.

Типы

Существует два типа отказоустойчивой схемы: Generic Mapping и Generic Sequence

Общее отображение

Он представляет собой ассоциативный контейнер. Здесь каждый ключ уникален в ассоциации и отображается ровно на одно значение. YAML не содержит ограничений для ключевых определений.

Пример для представления общего отображения приведен ниже -

Clark : Evans
Ingy : döt Net
Oren : Ben-Kiki
Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

Вывод общей структуры сопоставления в формате JSON показан ниже -

{
   "Oren": "Ben-Kiki", 
   "Ingy": "d\u00f6t Net", 
   "Clark": "Evans", 
   "Flow style": {
      "Oren": "Ben-Kiki", 
      "Ingy": "d\u00f6t Net", 
      "Clark": "Evans"
   }
}

Общая последовательность

Он представляет собой тип последовательности. Он включает коллекцию, индексированную последовательными целыми числами, начиная с нуля. Он представлен!!seq тег.

Clark : Evans
Ingy : döt Net
Oren : Ben-Kiki
Flow style: !!seq { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

Выходные данные для этой общей последовательности отказоустойчивых

schema is shown below:
{
   "Oren": "Ben-Kiki", 
   "Ingy": "d\u00f6t Net", 
   "Clark": "Evans", 
   "Flow style": {
      "Oren": "Ben-Kiki", 
      "Ingy": "d\u00f6t Net", 
      "Clark": "Evans"
   }
}

Схема JSON в YAML считается общим знаменателем большинства современных компьютерных языков. Он позволяет анализировать файлы JSON. В YAML настоятельно рекомендуется учитывать другие схемы в схеме JSON. Основная причина этого в том, что он включает в себя комбинацию ключевых значений, удобную для пользователя. Сообщения могут быть закодированы как ключевые и могут использоваться по мере необходимости.

Схема JSON является скалярной и не имеет значения. Запись сопоставления в схеме JSON представлена ​​в формате некоторой пары ключ-значение, где значение null считается допустимым.

пример

Пустая схема JSON представлена, как показано ниже -

!!null null: value for null key
key with null value: !!null null

Вывод представления JSON упомянут ниже -

{
   "null": "value for null key", 
   "key with null value": null
}

пример

В следующем примере представлена ​​логическая схема JSON -

YAML is a superset of JSON: !!bool true
Pluto is a planet: !!bool false

Ниже приведен вывод для того же в формате JSON -

{
   "YAML is a superset of JSON": true, 
   "Pluto is a planet": false
}

пример

В следующем примере представлена ​​целочисленная схема JSON -

negative: !!int -12
zero: !!int 0
positive: !!int 34

{
   "positive": 34, 
   "zero": 0, 
   "negative": -12
}

пример

Теги в схеме JSON представлены в следующем примере -

A null: null
Booleans: [ true, false ]
Integers: [ 0, -0, 3, -19 ]
Floats: [ 0., -0.0, 12e03, -2E+05 ]
Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]

Вы можете найти вывод JSON, как показано ниже -

{
   "Integers": [
      0, 
      0, 
      3, 
      -19
   ], 
   
   "Booleans": [
      true, 
      false
   ], 
   "A null": null, 

   "Invalid": [
         true, 
         null, 
         "0o7", 
         58, 
         12.300000000000001
   ], 
   
   "Floats": [
      0.0, 
      -0.0, 
      "12e03", 
      "-2E+05"
   ]
}