YAML - Collections and Structures

YAML包括對作用域使用縮進的塊集合。在這裡，每個條目都以新行開頭。集合中的塊序列用短劃線和空格表示每個條目。在YAML中，塊集合樣式不由任何特定的指示符表示。YAML中的塊集合可以通過包含的鍵值對的標識與其他標量區分開來。

映射是JSON結構中包含的鍵值的表示。它經常用於多語言支持系統和移動應用程式中API的創建。映射使用鍵值對表示，並使用冒號和空格（：）。

Examples

考慮一個標量序列的例子，例如下面顯示的一個球手列表;

- 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包含使用顯式指示符的流樣式，而不是使用縮進來表示空間。集合中的流序列以逗號分隔的列表形式寫入，並用方括號括起來。symphony等PHP框架中包含的集合的最佳說明。

[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 - Scalars and Tags

YAML中的標量是以塊格式編寫的，使用一個文本類型，該文本類型表示爲（|）。它表示換行計數。在YAML中，標量是以摺疊樣式（>）編寫的，其中每一行表示一個摺疊空間，該空間以空行或更縮進的行結尾。

新行以文字形式保留，如下所示;

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

摺疊的換行符保留爲更多縮進的行和空白行，如下所示−

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

YAML流標量包括普通樣式和引用樣式。雙引號樣式包括各種轉義序列。流標量可以包含多行;在此結構中，換行符總是摺疊的。

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

在YAML中，使用特定類型的應用程式指定未標記的節點。標記規範的示例通常使用YAML標記庫的seq、map和str類型。標籤被表示爲下面提到的例子;

Integer tags

這些標記中包含整數值。它們也被稱爲數字標記。

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

Floating point numbers

這些標記包括十進位和指數值。它們也被稱爲指數標記。

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

Miscellaneous Tags

它包含了嵌入在其中的各種整數、浮點和字符串值。因此它被稱爲雜項標記。

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

YAML - Full Length Example

下面的完整示例指定了YAML的構造，其中包括符號和各種表示，這些在轉換或處理JSON格式的符號和表示時會很有幫助。這些屬性在JSON文檔中也稱爲鍵名。這些符號是爲安全目的而創建的。

上面的YAML格式表示默認值、適配器和主機的各種屬性以及各種其他屬性。YAML還保存生成的每個文件的日誌，該日誌維護生成的錯誤消息的跟蹤。在以JSON格式轉換指定的YAML文件時，我們會得到如下所述的所需輸出−

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 - Processes

YAML遵循工藝流程的標準程序。YAML中的本機數據結構包括節點等簡單表示。它也稱爲表示節點圖。

它包括正在序列化以創建序列化樹的映射、序列和標量。通過序列化，對象被轉換爲字節流。

序列化事件樹有助於創建字符流的表示形式，如下圖所示。

反向過程將字節流解析爲序列化事件樹。然後，將節點轉換爲節點圖。這些值稍後將在YAML本機數據結構中轉換。下圖說明了這一點;

YAML中的信息有兩種使用方式：機器處理和人類消費。YAML中的處理器用作在上圖中的互補視圖之間轉換信息的過程的工具。本章描述了YAML處理器在給定應用程式中必須提供的信息結構。

YAML包含一個序列化過程，用於以串行格式表示數據對象。YAML信息的處理包括表示、序列化、表示和解析三個階段。讓我們詳細討論每一個問題。

Representation

YAML使用三種節點表示數據結構：序列、映射和標量。

Sequence

序列是指有順序的條目數，它映射鍵值對的無序關聯。它對應於Perl或Python數組列表。

下面顯示的代碼是序列表示的一個示例−

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

Mapping

另一方面，映射表示字典數據結構或哈希表。下面是一個相同的例子;

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

Scalars

標量表示字符串、整數、日期和原子數據類型的標準值。注意，YAML還包括指定數據類型結構的節點。有關標量的更多信息，請參閱本教程的第6章。

Serialization

在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']

Presentation

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"
               ]
            }
         }
      }
   }
}

Parsing

解析是表示的逆過程;它包含一個字符流並創建一系列事件。它丟棄表示過程中引入的導致序列化事件的詳細信息。解析過程可能由於輸入格式錯誤而失敗。這基本上是一個檢查山藥是否成型的程序。

考慮下面提到的一個YAML示例;

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

它用三個連字符表示文檔的開頭，後面在文檔中定義了各種屬性。

YAML lint是YAML的在線解析器，有助於解析YAML結構以檢查它是否有效。YAML lint的官方連結如下所述：http://www.yamllint.com/

您可以看到如下所示的解析輸出;

YAML - Information Models

本章將詳細說明我們在上一章中討論的程序和過程。YAML中的信息模型將使用特定的圖表以系統格式指定序列化和表示過程的特性。

對於一個信息模型來說，在編程環境之間表示可移植的應用程式信息是很重要的。

上面所示的圖表示了一個正常的信息模型，它以圖形格式表示。在YAML中，本機數據的表示是根的、連接的，並且是標記節點的有向圖。如果我們提到有向圖，它包含一組有向圖的節點。正如在信息模型中所提到的，YAML支持三種節點，即−

• Sequences
• Scalars
• Mappings

最後一章討論了這些表示節點的基本定義。在本章中，我們將重點討論這些術語的示意圖。下面的序列圖表示具有各種類型標記和映射節點的圖例的工作流。

有三種類型的節點：序列節點、標量節點和映射節點。

Sequences

序列節點遵循順序體系結構，包括一個由零個或多個節點組成的有序序列。YAML序列可以重複包含同一個節點，也可以包含單個節點。

Scalars

YAML中標量的內容包括Unicode字符，這些字符可以用一系列零表示。一般來說，標量節點包含標量。

Mapping

映射節點包括鍵值對表示。映射節點的內容包括一個鍵值對的組合，該鍵值對的強制條件是鍵名應保持唯一。序列和映射共同構成一個集合。

注意，如上圖所示，標量、序列和映射以系統格式表示。

YAML - Syntax Characters

各種類型的字符用於各種功能。本章詳細討論了YAML中使用的語法，並重點討論了字符操作。

Indicator Characters

指示符包括一種特殊的語義，用於描述YAML文檔的內容。下表詳細說明了這一點。

下面的示例顯示語法中使用的字符−

%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 - Syntax Primitives

在本章中，您將了解YAML−中語法原語的以下方面;

• Production parameters
• Indentation Spaces
• Separation Spaces
• Ignored Line Prefix
• Line folding

讓我們詳細了解每一個方面。

Production Parameters

生產參數包括一組參數和用於特定生產的允許值的範圍。以下生產參數列表用於YAML−

Indentation

它由字符n或m表示，字符流取決於包含在其中的塊的縮進級別。許多產品已將這些特性參數化。

Context

它由c表示。YAML支持兩組上下文：塊樣式和流樣式。

Style

它由s表示。標量內容可以用以下五種樣式之一表示：普通、雙引號和單引號流、文本和摺疊塊

Chomping

它由t表示。塊標量提供了許多有助於修剪塊的機制：strip、clip和keep。Chomping有助于格式化新行字符串。它使用塊樣式表示。Chomping過程是在指示器的幫助下發生的。這些指示器控制應該用換行字符串生成什麼輸出。用（-）運算符刪除換行符，用（+）運算符添加換行符。

下面顯示了一個chomping過程的示例;

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

解析指定的YAML示例後的輸出如下所示−

Indentation Spaces

在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"
      ]
   }
}

Separation Spaces

YAML使用空格字符來分隔令牌。最重要的一點是YAML中的分隔不應該包含制表符。

下面一段代碼展示了分隔空間的用法−

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

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

Ignored Line Prefix

空前綴始終包括縮進，這取決於標量類型，標量類型還包括前導空格。普通標量不應包含任何制表符。另一方面，帶引號的標量可以包含制表符。塊標量完全依賴於縮進。

下面的示例以系統的方式顯示忽略的行前綴的工作方式;

%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"
}

Line Folding

折線允許爲了可讀性而打斷長線。更多的短線意味著更好的可讀性。折線是通過標註長線的原始語義來實現的。下面的示例演示折線−

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

您可以看到JSON格式的折線輸出，如下所示−

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

YAML - Character Streams

在YAML中，您會遇到各種字符流，如下所示;

• Directives
• Document Boundary Markers
• Documents
• Complete Stream

在這一章中，我們將詳細討論它們。

Directives

指令是YAML處理器中使用的基本指令。指令是表示詳細信息，如注釋，它們不會反映在序列化樹中。在YAML中，無法定義私有指令。本節討論各種類型的指令以及相關的示例−

Reserved Directives

保留指令用三個連字符（--）初始化，如下例所示。保留的指令被轉換爲JSON的特定值。

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

YAML Directive

YAML指令是默認指令。如果轉換爲JSON格式，則獲取的值包括前向和終止字符中的正斜槓字符。

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

Document Boundary Markers

YAML使用這些標記允許在一個流中包含多個文檔。這些標記是專門用來表達YAML文檔結構的。請注意，以「---」開頭的行用於啓動新文檔。

下面的代碼用示例說明了這一點;

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

Documents

YAML文檔被視爲一個單獨的原生數據結構，以單個根節點的形式呈現。YAML文檔中的表示細節（如指令、注釋、縮進和樣式）不視爲包含在其中的內容。

YAML中使用了兩種類型的文檔。本節將對它們進行解釋;

Explicit Documents

它從文檔開始標記開始，然後是根節點的表示。下面給出了YAML顯式聲明的示例−

---

some: yaml

...

它包括一個顯式的開始和結束標記，在給定的示例中是「---」和「…」。在將指定的YAML轉換爲JSON格式時，我們得到如下所示的輸出;

{
   "some": "yaml"
}

Implicit Documents

這些文檔不是以文檔開始標記開頭的。遵守下面給出的代碼&負;

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

將這些值轉換爲JSON格式，我們將輸出作爲一個簡單的JSON對象，如下所示−

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

Complete Stream

YAML包含一個稱爲字符流的字節序列。流以包含表示字符編碼的字節順序的前綴開頭。完整的流以包含字符編碼的前綴開頭，後跟注釋。

完整流（字符流）的示例如下所示−

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

YAML - Node Properties

每個表示節點包含兩個主要特徵，稱爲錨定和標記。可以使用節點內容指定節點屬性，從字符流中省略。

節點表示的基本示例如下−

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

Node Anchors

anchor屬性表示一個節點以供將來參考。節點中YAML表示的字符流用與號（&）指示符表示。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",
}

Node Tags

The tag property represents the type of native data structure which defines a node completely. A tag is represented with the (啊！) indicator. Tags are considered as an inherent part of the representation graph. The following example of explains node tags in detail −

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

Node Content

節點內容可以用流內容或塊格式表示。塊內容擴展到行尾並使用縮進表示結構。每種集合類型可以用特定的單流集合樣式表示，也可以視爲單個塊。下面的代碼詳細解釋了這一點;

%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 - Block Scalar Header

在本章中，我們將重點討論用於表示內容的各種標量類型。在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"
   }
}

Document Marker Scalar Content

此示例中的所有字符都視爲內容，包括內部空間字符。

%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 - Flow Styles

YAML中的流樣式可以看作是JSON的自然擴展，可以覆蓋可摺疊的內容行，以獲得更可讀的特性，該特性使用錨和別名來創建對象實例。在本章中，我們將重點討論以下概念的流表示法&負;

• Alias Nodes
• Empty Nodes
• Flow Scalar styles
• Flow collection styles
• Flow nodes

別名節點的示例如下所示−

%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"
      }
   ] 
}

Flow collection in YAML is nested with a block collection within another flow collection. Flow collection entries are terminated with comma (我是說) indicator. The following example explains the flow collection block in detail −

%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 - Block Styles

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"
]

Types of Block Styles

有四種類型的塊樣式：文字樣式、摺疊樣式、保留樣式和條形樣式。這些塊樣式是在塊選擇場景的幫助下定義的。下面給出了一個block-chomping場景的示例;

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

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

# 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

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

%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

{
   "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"
         }
      }
   ]
}

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

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

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

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

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

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"
   }
}

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

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

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

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

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

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

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 ]