YAML - Guia rápido

YAML Ain't Markup Language é uma linguagem de serialização de dados que corresponde às expectativas do usuário sobre os dados. Ele foi projetado para ser amigável e funciona perfeitamente com outras linguagens de programação. É útil para gerenciar dados e inclui caracteres Unicode imprimíveis. Este capítulo lhe dará uma introdução ao YAML e dará uma ideia sobre seus recursos.

Formato

Considere o texto mostrado abaixo -

Quick brown fox jumped over the lazy dog.

O texto YAML para isso será representado conforme mostrado abaixo -

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

Observe que YAML assume o valor no formato de string e representa a saída conforme mencionado acima.

Exemplos

Vamos entender os formatos em YAML com a ajuda dos seguintes exemplos -

Considere o seguinte número de ponto de “pi”, que tem um valor de 3,1415926. Em YAML, é representado como um número flutuante, conforme mostrado abaixo -

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

Suponha que vários valores sejam carregados na estrutura de dados específica, conforme mencionado abaixo -

eggs
ham
spam
French basil salmon terrine

Quando você carrega isso no YAML, os valores são obtidos em uma estrutura de dados de matriz que é uma forma de lista. A saída é como mostrado abaixo -

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

Características

YAML inclui uma linguagem de marcação com construção importante, para distinguir a linguagem orientada a dados com a marcação do documento. Os objetivos de design e recursos do YAML são fornecidos abaixo -

  • Combina estruturas de dados nativas de metodologia ágil e suas linguagens como Perl, Python, PHP, Ruby e JavaScript

  • Dados YAML são portáteis entre linguagens de programação

  • Inclui modelo de dados consistente de dados

  • Facilmente legível por humanos

  • Suporta processamento unidirecional

  • Facilidade de implementação e uso

Agora que você tem uma ideia sobre YAML e seus recursos, vamos aprender seus fundamentos com sintaxe e outras operações. Lembre-se de que YAML inclui um formato estruturado legível por humanos.

Regras para criar arquivo YAML

Ao criar um arquivo em YAML, você deve se lembrar das seguintes regras básicas:

  • YAML diferencia maiúsculas de minúsculas

  • Os arquivos deveriam ter .yaml como a extensão

  • YAML não permite o uso de guias ao criar arquivos YAML; espaços são permitidos ao invés

Componentes básicos do arquivo YAML

Os componentes básicos do YAML são descritos abaixo -

Formato de Bloco Convencional

Este formato de bloco usa hyphen+spacepara começar um novo item em uma lista especificada. Observe o exemplo mostrado abaixo -

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

Inline Format

O formato embutido é delimitado com comma and spacee os itens são colocados em JSON. Observe o exemplo mostrado abaixo -

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

Folded Text

O texto dobrado converte novas linhas em espaços e remove os espaços em branco à esquerda. Observe o exemplo mostrado abaixo -

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

A estrutura que segue todas as convenções básicas de YAML é mostrada abaixo -

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

Sinopse dos Elementos Básicos YAML

  • A sinopse dos elementos básicos YAML é dada aqui: Comentários em YAML começam com o (#) personagem.

  • Os comentários devem ser separados de outros tokens por espaços em branco.

  • O recuo de espaços em branco é usado para denotar a estrutura.

  • As guias não são incluídas como indentação para arquivos YAML.

  • Os membros da lista são indicados por um hífen inicial (-)

  • Os membros da lista são colocados entre colchetes e separados por vírgulas.

  • Matrizes associativas são representadas usando dois pontos ( : )no formato de par de valores-chave. Eles estão entre chaves{}.

  • Vários documentos com fluxos únicos são separados por 3 hifens (---).

  • Nós repetidos em cada arquivo são inicialmente denotados por um E comercial (&) e por um asterisco (*) marcar mais tarde.

  • YAML sempre requer dois pontos e vírgulas usados ​​como separadores de lista seguidos por espaço com valores escalares.

  • Os nós devem ser marcados com um ponto de exclamação (!) ou ponto de exclamação duplo (!!), seguido por uma string que pode ser expandida em um URI ou URL.

Indentação e separação são dois conceitos principais quando você está aprendendo qualquer linguagem de programação. Este capítulo fala sobre esses dois conceitos relacionados ao YAML em detalhes.

Recuo de YAML

YAML não inclui espaços obrigatórios. Além disso, não há necessidade de ser consistente. O recuo YAML válido é mostrado abaixo -

a:
   b:
      - c
      -  d
      - e
f:
      "ghi"
  • Você deve se lembrar das seguintes regras ao trabalhar com indentação em YAML: Os blocos de fluxo devem ter pelo menos alguns espaços circundando o nível do bloco atual.

  • O conteúdo do fluxo de YAML abrange várias linhas. O início do conteúdo do fluxo começa com{ ou [.

  • Os itens da lista de blocos incluem o mesmo recuo que o nível do bloco circundante porque - é considerado parte do recuo.

Exemplo de bloco pretendido

Observe o seguinte código que mostra recuo com exemplos -

--- !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.

Separação de Strings

Strings são separados usando string entre aspas duplas. Se você escapar dos caracteres de nova linha em uma determinada string, ela será completamente removida e convertida em valor de espaço.

Exemplo

Neste exemplo, focamos na listagem de animais listados como uma estrutura de array com tipo de dados de string. Cada novo elemento é listado com um prefixo de hífen conforme mencionado como prefixo.

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

Outro exemplo para explicar a representação de string em YAML é mencionado abaixo.

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

Este exemplo se refere ao conjunto de mensagens de erro que um usuário pode usar apenas mencionando o aspecto-chave e buscar os valores de acordo. Este padrão de YAML segue a estrutura de JSON, que pode ser entendida pelo usuário que é novo em YAML.

Agora que você está confortável com a sintaxe e os fundamentos do YAML, vamos prosseguir com seus detalhes. Neste capítulo, veremos como usar comentários em YAML.

YAML supports single line comments. Sua estrutura é explicada a seguir com a ajuda de um exemplo -

# this is single line comment.

YAML does not support multi line comments. Se você quiser fornecer comentários para várias linhas, pode fazê-lo conforme mostrado no exemplo abaixo -

# this
# is a multiple
# line comment

Características dos comentários

Os recursos dos comentários em YAML são fornecidos abaixo -

  • Um bloco comentado é ignorado durante a execução.

  • Os comentários ajudam a adicionar uma descrição para o bloco de código especificado.

  • Os comentários não devem aparecer dentro dos escalares.

  • YAML não inclui nenhuma maneira de escapar do símbolo hash (#), portanto, dentro da string de várias linhas, portanto, não há como dividir o comentário do valor da string bruta.

Os comentários dentro de uma coleção são mostrados abaixo -

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

A combinação de teclas de atalho para comentar blocos YAML é Ctrl+Q.

Se você estiver usando Sublime Text editor, as etapas para comentar o bloco são mencionadas abaixo -

Selecione o bloco. Use “CTRL + /” no Linux e Windows e “CMD + /” no sistema operacional Mac. Execute o bloqueio.

Observe que as mesmas etapas são aplicáveis ​​se você estiver usando Visual Studio Code Editor. É sempre recomendável usarSublime Text Editor para criar arquivos YAML, pois é compatível com a maioria dos sistemas operacionais e inclui teclas de atalho para desenvolvedores.

YAML inclui coleções de blocos que usam indentação para o escopo. Aqui, cada entrada começa com uma nova linha. Sequências de blocos em coleções indicam cada entrada com umdash and space(-). Em YAML, estilos de coleções de blocos não são denotados por nenhum indicador específico. A coleção de blocos em YAML pode ser distinguida de outras quantidades escalares com uma identificação de par de valores-chave incluídos nelas.

Os mapeamentos são a representação do valor-chave conforme incluído na estrutura JSON. É frequentemente usado em sistemas de suporte multilíngue e criação de API em aplicativos móveis. Os mapeamentos usam a representação do par de valores-chave com o uso decolon and space (:)

Exemplos

Considere um exemplo de sequência de escalares, por exemplo, uma lista de jogadores de bola como mostrado abaixo -

- Mark Joseph
- James Stephen
- Ken Griffey

O exemplo a seguir mostra o mapeamento de escalares para escalares -

hr: 87
avg: 0.298
rbi: 149

O exemplo a seguir mostra o mapeamento de escalares para sequências -

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

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

As coleções podem ser usadas para mapeamentos de sequência que são mostrados abaixo -

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

Com coleções, YAML inclui estilos de fluxo usando indicadores explícitos em vez de usar indentação para denotar espaço. A sequência do fluxo nas coleções é escrita como uma lista separada por vírgulas entre colchetes. A melhor ilustração para coleção que está incluída em estruturas de PHP como o symphony.

[PHP, Perl, Python]

Essas coleções são armazenadas em documentos. A separação de documentos em YAML é denotada por três hífens ou travessões (---). O final do documento está marcado com três pontos (…).

A separação de documentos em YAML é indicada por três travessões (---). O final do documento é representado por três pontos (…).

A representação do documento é referida como formato de estrutura que é mencionado abaixo -

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

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

Um ponto de interrogação com uma combinação de espaço indica um mapeamento complexo na estrutura. Em uma coleção de blocos, um usuário pode incluir uma estrutura com um traço, dois pontos e um ponto de interrogação. O exemplo a seguir mostra o mapeamento entre sequências -

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

Os escalares em YAML são escritos em formato de bloco usando um tipo literal que é denotado como (|) Ele denota a contagem de quebras de linha. Em YAML, os escalares são escritos em estilo dobrado (>) onde cada linha denota um espaço dobrado que termina com um empty line ou more indented linha.

Novas linhas são preservadas em literais são mostradas abaixo -

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

As novas linhas dobradas são preservadas por more indented lines e blank lines como mostrado abaixo -

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

Os escalares de fluxo YAML incluem estilos simples e estilos citados. O estilo de aspas duplas inclui várias sequências de escape. Os escalares de fluxo podem incluir várias linhas; as quebras de linha são sempre dobradas nesta estrutura.

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

Em YAML, nós não marcados são especificados com um tipo específico de aplicativo. Os exemplos de especificação de tags geralmente usamseq, map e strtipos para repositório de tag YAML. As tags são representadas como exemplos mencionados abaixo -

Tags inteiras

Essas marcas incluem valores inteiros nelas. Eles também são chamados de tags numéricas.

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

Números de ponto flutuante

Essas tags incluem valores decimais e exponenciais. Eles também são chamados de tags exponenciais.

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

Tags diversas

Inclui uma variedade de valores inteiros, flutuantes e de string embutidos neles. Por isso é chamado de tags diversas.

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

O exemplo completo a seguir especifica a construção de YAML, que inclui símbolos e várias representações que serão úteis ao convertê-los ou processá-los no formato JSON. Esses atributos também são chamados de nomes-chave em documentos JSON. Essas notações são criadas para fins de segurança.

O formato YAML acima representa vários atributos de padrões, adaptador e host com vários outros atributos. YAML também mantém um registro de cada arquivo gerado, o que mantém um registro das mensagens de erro geradas. Ao converter o arquivo YAML especificado no formato JSON, obtemos a saída desejada, conforme mencionado abaixo -

defaults: &defaults
   adapter:  postgres
   host:     localhost

development:
   database: myapp_development
   <<: *defaults

test:
   database: myapp_test
   <<: *defaults

Vamos converter o formato YAML para JSON e verificar a saída.

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

A chave padrão com um prefixo “<<: *” é incluída como e quando necessária, sem a necessidade de escrever o mesmo trecho de código repetidamente.

YAML segue um procedimento padrão para o fluxo do processo. A estrutura de dados nativa em YAML inclui representações simples, como nós. Também é chamado de Gráfico de Nó de Representação.

Inclui mapeamento, sequência e quantidades escalares que estão sendo serializadas para criar uma árvore de serialização. Com a serialização, os objetos são convertidos com fluxo de bytes.

A árvore de eventos de serialização ajuda a criar a apresentação de fluxos de caracteres, conforme representado no diagrama a seguir.

O procedimento reverso analisa o fluxo de bytes na árvore de eventos serializada. Posteriormente, os nós são convertidos em gráfico de nós. Esses valores são posteriormente convertidos na estrutura de dados nativa YAML. A figura abaixo explica isso -

As informações em YAML são usadas de duas maneiras: machine processing e human consumption. O processador em YAML é usado como uma ferramenta para o procedimento de conversão de informações entre visualizações complementares no diagrama fornecido acima. Este capítulo descreve as estruturas de informação que um processador YAML deve fornecer em um determinado aplicativo.

YAML inclui um procedimento de serialização para representar objetos de dados em formato serial. O processamento de informações YAML inclui três etapas:Representation, Serialization, Presentation and parsing. Vamos discutir cada um deles em detalhes.

Representação

YAML representa a estrutura de dados usando três tipos de nós: sequence, mapping e scalar.

Seqüência

Sequência se refere ao número ordenado de entradas, que mapeia a associação não ordenada do par de valores-chave. Corresponde à lista de matrizes Perl ou Python.

O código mostrado abaixo é um exemplo de representação de sequência -

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

Mapeamento

O mapeamento, por outro lado, representa a estrutura de dados do dicionário ou a tabela hash. Um exemplo do mesmo é mencionado abaixo -

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

Escalares

Os escalares representam valores padrão de strings, inteiros, datas e tipos de dados atômicos. Observe que YAML também inclui nós que especificam a estrutura do tipo de dados. Para obter mais informações sobre escalares, consulte o capítulo 6 deste tutorial.

Serialização

O processo de serialização é necessário em YAML, o que facilita a ordem de chaves e nomes de âncora amigáveis. O resultado da serialização é uma árvore de serialização YAML. Ele pode ser percorrido para produzir uma série de chamadas de eventos de dados YAML.

Um exemplo de serialização é fornecido abaixo -

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

Apresentação

A saída final da serialização YAML é chamada de apresentação. Ele representa o fluxo de um personagem de uma maneira humana amigável. O processador YAML inclui vários detalhes de apresentação para a criação de fluxo, manipulação de indentação e formatação de conteúdo. Este processo completo é guiado pelas preferências do usuário.

Um exemplo de processo de apresentação YAML é o resultado do valor JSON criado. Observe o código fornecido abaixo para um melhor entendimento -

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

Análise

A análise é o processo inverso de apresentação; inclui um fluxo de personagens e cria uma série de eventos. Ele descarta os detalhes introduzidos no processo de apresentação que causa eventos de serialização. O procedimento de análise pode falhar devido a uma entrada malformada. É basicamente um procedimento para verificar se o YAML está bem formado ou não.

Considere um exemplo YAML que é mencionado abaixo -

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

Com três hifens, representa o início do documento com vários atributos definidos posteriormente nele.

YAML lint é o analisador online de YAML e ajuda a analisar a estrutura YAML para verificar se ela é válida ou não. O link oficial para YAML lint é mencionado abaixo:http://www.yamllint.com/

Você pode ver a saída da análise conforme mostrado abaixo -

Este capítulo explicará os detalhes sobre os procedimentos e processos que discutimos no capítulo anterior. Modelos de informação em YAML irão especificar os recursos de serialização e procedimento de apresentação em um formato sistemático usando um diagrama específico.

Para um modelo de informação, é importante representar as informações do aplicativo que são portáveis ​​entre ambientes de programação.

O diagrama mostrado acima representa um modelo de informação normal que é representado em formato de gráfico. Em YAML, a representação de dados nativos é enraizada, conectada e é um gráfico direcionado de nós marcados. Se mencionarmos o grafo direcionado, ele inclui um conjunto de nós com o grafo direcionado. Conforme mencionado no modelo de informação, YAML suporta três tipos de nós, a saber -

  • Sequences
  • Scalars
  • Mappings

As definições básicas desses nós de representação foram discutidas no último capítulo. Neste capítulo, vamos nos concentrar na visão esquemática desses termos. O diagrama de sequência a seguir representa o fluxo de trabalho de legendas com vários tipos de tags e nós de mapeamento.

Existem três tipos de nós: sequence node, scalar node e mapping node.

Sequências

O nó de sequência segue uma arquitetura sequencial e inclui uma série ordenada de zero ou mais nós. Uma sequência YAML pode conter o mesmo nó repetidamente ou um único nó.

Escalares

O conteúdo dos escalares em YAML inclui caracteres Unicode que podem ser representados no formato com uma série de zero. Em geral, o nó escalar inclui quantidades escalares.

Mapeamento

O nó de mapeamento inclui a representação do par de valores-chave. O conteúdo do nó de mapeamento inclui uma combinação de par de valores-chave com uma condição obrigatória de que o nome da chave deve ser mantido exclusivo. Sequências e mapeamentos coletivamente formam uma coleção.

Observe que, conforme representado no diagrama mostrado acima, escalares, sequências e mapeamentos são representados em um formato sistemático.

Vários tipos de caracteres são usados ​​para várias funcionalidades. Este capítulo fala em detalhes sobre a sintaxe usada em YAML e se concentra na manipulação de caracteres.

Caracteres Indicadores

Os caracteres indicadores incluem uma semântica especial usada para descrever o conteúdo do documento YAML. A tabela a seguir mostra isso em detalhes.

Sr. Não. Caráter e Funcionalidade
1

_

Isso denota uma entrada de sequência de bloco

2

?

Denota uma chave de mapeamento

3

:

Isso denota um valor de mapeamento

4

,

Denota entrada de coleta de fluxo

5

[

Ele inicia uma sequência de fluxo

6

]

Termina uma sequência de fluxo

7

{

Ele inicia um mapeamento de fluxo

8

}

Termina um mapeamento de fluxo

9

#

Denota os comentários

10

&

Ele denota a propriedade âncora do nó

11

*

Denota um nó de alias

12

!

Ele denota a marca do nó

13

|

Isso denota um escalar de bloco literal

14

>

Isso denota um escalar de bloco dobrado

15

`

Aspas simples circundam um escalar de fluxo entre aspas

16

"

Aspas duplas circundam o escalar de fluxo entre aspas

17

%

Denota a diretiva usada

O exemplo a seguir mostra os caracteres usados ​​na sintaxe -

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

Neste capítulo, você aprenderá sobre os seguintes aspectos das primitivas de sintaxe em YAML -

  • Parâmetros de produção
  • Espaços de Indentação
  • Espaços de Separação
  • Prefixo de linha ignorado
  • Dobragem de linha

Vamos entender cada aspecto em detalhes.

Parâmetros de Produção

Os parâmetros de produção incluem um conjunto de parâmetros e a faixa de valores permitidos que são usados ​​em uma produção específica. A seguinte lista de parâmetros de produção é usada em YAML -

Recuo

É denotado por personagem n ou mO fluxo de caracteres depende do nível de recuo dos blocos incluídos nele. Muitas produções parametrizaram esses recursos.

Contexto

É denotado por c. YAML suporta dois grupos de contextos:block styles e flow styles.

Estilo

É denotado por s. O conteúdo escalar pode ser apresentado em um dos cinco estilos:plain, double quoted and single quoted flow, literal and folded block.

Mastigando

É denotado por t. Os escalares de bloco oferecem muitos mecanismos que ajudam a aparar o bloco:strip, clip e keep. Chomping ajuda na formatação de novas strings de linha. É usada a representação do estilo de bloco. O processo de mastigação acontece com a ajuda de indicadores. Os indicadores controlam qual saída deve ser produzida com novas linhas de string. As novas linhas são removidas com(-) operador e novas linhas são adicionados com (+) operador.

Um exemplo de processo de mastigação é mostrado abaixo -

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

A saída depois de analisar o exemplo YAML especificado é a seguinte -

Espaços de Indentação

No fluxo de caracteres YAML, o recuo é definido como um caractere de quebra de linha de zero ou mais caracteres. O ponto mais importante a ser mantido em mente é que a indentação não deve conter caracteres de tabulação. Os caracteres em indentação nunca devem ser considerados como parte das informações de conteúdo do nó. Observe o seguinte código para melhor compreensão -

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

A saída que você pode ver após o recuo é a seguinte -

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

Espaços de Separação

YAML usa caracteres de espaço para separação entre tokens. A observação mais importante é que a separação em YAML não deve conter caracteres de tabulação.

O seguinte único código mostra o uso de espaços de separação -

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

Prefixo de linha ignorado

O prefixo vazio sempre inclui indentação, dependendo do tipo escalar que também inclui um espaço em branco à esquerda. Os escalares simples não devem conter caracteres de tabulação. Por outro lado, os escalares entre aspas podem conter caracteres de tabulação. Os escalares de bloco dependem completamente da indentação.

O exemplo a seguir mostra o funcionamento do prefixo de linha ignorado de uma maneira sistemática -

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

A saída obtida para os fluxos de bloco é a seguinte -

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

Line Folding

A dobragem de linha permite quebrar linhas longas para facilitar a leitura. Mais linhas curtas significam melhor legibilidade. A dobra de linha é obtida observando-se a semântica original da linha longa. O exemplo a seguir demonstra a dobra de linha -

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

Você pode ver a saída da dobra de linha no formato JSON da seguinte maneira -

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

Em YAML, você encontra vários fluxos de personagens da seguinte maneira -

  • Directives
  • Marcadores de limite de documento
  • Documents
  • Stream completo

Neste capítulo, iremos discuti-los em detalhes.

Diretivas

As diretivas são instruções básicas usadas no processador YAML. As diretivas são os detalhes da apresentação, como comentários, que não são refletidos na árvore de serialização. Em YAML, não há como definir diretivas privadas. Esta seção discute vários tipos de diretivas com exemplos relevantes -

Diretivas Reservadas

As diretivas reservadas são inicializadas com três caracteres de hífen (---), conforme mostrado no exemplo abaixo. As diretivas reservadas são convertidas em valor específico de JSON.

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

Diretiva YAML

Diretivas YAML são diretivas padrão. Se convertido em JSON, o valor buscado inclui o caractere de barra nos caracteres anteriores e finais.

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

Marcadores de limite de documento

YAML usa esses marcadores para permitir que mais de um documento esteja contido em um fluxo. Esses marcadores são usados ​​especialmente para transmitir a estrutura do documento YAML. Observe que uma linha começando com “---“ é usada para iniciar um novo documento.

O código a seguir explica isso com exemplos -

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

Documentos

O documento YAML é considerado como uma única estrutura de dados nativa apresentada como um único nó raiz. Os detalhes da apresentação no documento YAML, como diretivas, comentários, recuos e estilos, não são considerados como conteúdos neles incluídos.

Existem dois tipos de documentos usados ​​em YAML. Eles são explicados nesta seção -

Documentos Explícitos

Ele começa com o marcador de início do documento seguido pela apresentação do nó raiz. O exemplo de declaração explícita YAML é fornecido abaixo -

---

some: yaml

...

Inclui marcadores de início e fim explícitos que são “---“ e “…” em determinado exemplo. Ao converter o YAML especificado no formato JSON, obtemos a saída conforme mostrado abaixo -

{
   "some": "yaml"
}

Documentos implícitos

Esses documentos não começam com um marcador de início de documento. Observe o código fornecido abaixo -

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

Convertendo esses valores no formato JSON, obtemos a saída como um objeto JSON simples, conforme fornecido abaixo -

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

Stream completo

YAML inclui uma sequência de bytes chamada de fluxo de caracteres. O fluxo começa com um prefixo contendo uma ordem de bytes denotando uma codificação de caracteres. O fluxo completo começa com um prefixo contendo uma codificação de caracteres, seguido por comentários.

Um exemplo de fluxo completo (fluxo de caracteres) é mostrado abaixo -

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

Cada nó de apresentação inclui duas características principais chamadas anchor e tag. As propriedades do nó podem ser especificadas com o conteúdo do nó, omitido do fluxo de caracteres.

O exemplo básico de representação do nó é o seguinte -

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

Nó âncoras

A propriedade anchor representa um nó para referência futura. O fluxo de caracteres da representação YAML no nó é denotado com oampersand (&)indicador. O processador YAML não precisa preservar o nome da âncora com os detalhes de representação compostos nele. O código a seguir explica isso -

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

A saída de YAML gerado com nós âncora é mostrada abaixo -

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

Tags de nó

A propriedade tag representa o tipo de estrutura de dados nativa que define um nó completamente. Uma tag é representada com o (!) indicador. As tags são consideradas parte inerente do gráfico de representação. O exemplo a seguir explica as tags de nó em detalhes -

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

Conteúdo de Nó

O conteúdo do nó pode ser representado em um conteúdo de fluxo ou formato de bloco. O conteúdo do bloco se estende até o final da linha e usa recuo para denotar a estrutura. Cada tipo de coleção pode ser representado em um estilo de coleção de fluxo único específico ou pode ser considerado como um bloco único. O código a seguir explica isso em detalhes -

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

Neste capítulo, vamos nos concentrar em vários tipos escalares que são usados ​​para representar o conteúdo. Em YAML, os comentários podem preceder ou seguir o conteúdo escalar. É importante observar que os comentários não devem ser incluídos no conteúdo escalar.

Observe que todos os estilos escalares de fluxo podem incluir várias linhas, exceto com o uso em várias chaves.

A representação dos escalares é dada abaixo -

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

A saída gerada dos cabeçalhos escalares do bloco é mostrada abaixo -

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

Conteúdo escalar do marcador de documento

Todos os caracteres neste exemplo são considerados como conteúdo, incluindo os caracteres de espaço interno.

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

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

As quebras de linha simples são representadas com o exemplo abaixo -

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

A saída JSON correspondente para o mesmo é mencionada abaixo -

"as space trimmed\nspecific\u2028\nnone"

Os estilos de fluxo em YAML podem ser considerados uma extensão natural do JSON para cobrir as linhas de conteúdo dobráveis ​​para um recurso mais legível que usa âncoras e apelidos para criar as instâncias do objeto. Neste capítulo, vamos nos concentrar na representação do fluxo dos seguintes conceitos -

  • Nós de alias
  • Nós Vazios
  • Estilos escalares de fluxo
  • Estilos de coleta de fluxo
  • Nós de fluxo

O exemplo de nós de alias é mostrado abaixo -

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

A saída JSON do código fornecido acima é fornecida abaixo -

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

Os nós com conteúdo vazio são considerados nós vazios. O exemplo a seguir mostra isso -

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

A saída de nós vazios em JSON é representada como abaixo -

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

Os estilos escalares de fluxo incluem aspas duplas, aspas simples e tipos simples. O exemplo básico para o mesmo é dado abaixo -

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

A saída no formato JSON para o exemplo fornecido acima é mostrada abaixo -

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

A coleção de fluxo em YAML é aninhada com uma coleção de bloco dentro de outra coleção de fluxo. As entradas de coleta de fluxo são encerradas comcomma (,) indicador. O exemplo a seguir explica o bloco de coleta de fluxo em detalhes -

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

A saída para coleta de fluxo em JSON é mostrada abaixo -

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

Estilos de fluxo como JSON incluem indicadores de início e fim. O único estilo de fluxo que não possui nenhuma propriedade é o escalar simples.

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

A saída para o código mostrado acima no formato JSON é fornecida abaixo -

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

YAML inclui dois estilos escalares de bloco: literal e folded. Os escalares de bloco são controlados com poucos indicadores com um cabeçalho precedendo o próprio conteúdo. Um exemplo de cabeçalhos escalares de bloco é fornecido abaixo -

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

A saída no formato JSON com um comportamento padrão é fornecida abaixo -

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

Tipos de estilos de bloco

Existem quatro tipos de estilos de bloco: literal, folded, keep e stripestilos. Esses estilos de bloco são definidos com a ajuda do cenário Block Chomping. Um exemplo de cenário de mastigação de blocos é dado abaixo -

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

Você pode ver a saída gerada com três formatos em JSON conforme fornecido abaixo -

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

Chomping em YAML controla as quebras finais e linhas vazias finais que são interpretadas de várias formas.

Stripping

Nesse caso, a quebra de linha final e as linhas vazias são excluídas do conteúdo escalar. É especificado pelo indicador de mastigação “-“.

Clipping

O recorte é considerado um comportamento padrão se nenhum indicador de trituração explícito for especificado. O caractere de quebra final é preservado no conteúdo do escalar. O melhor exemplo de recorte é demonstrado no exemplo acima. Termina com nova linha“\n” personagem.

Guardando

Manter refere-se à adição com representação do indicador de mastigação “+”. As linhas adicionais criadas não estão sujeitas a dobragem. As linhas adicionais não estão sujeitas a dobragem.

Para entender os estilos de sequência, é importante entender as coleções. O conceito de coleções e estilos de sequência funcionam em paralelo. A coleção em YAML é representada com estilos de sequência apropriados. Se você quiser se referir ao sequenciamento adequado de tags, sempre consulte as coleções. Coleções em YAML são indexadas por inteiros sequenciais começando com zero, conforme representado em matrizes. O foco dos estilos de sequência começa com as coleções.

Exemplo

Vamos considerar o número de planetas no universo como uma sequência que pode ser criada como uma coleção. O código a seguir mostra como representar os estilos de sequência de planetas no universo -

# 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

Então, você pode ver a seguinte saída para a sequência ordenada no formato JSON -

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

Os mapeamentos de fluxo em YAML representam a coleção não ordenada de pares de valores-chave. Eles também são chamados de nó de mapeamento. Observe que as chaves devem ser mantidas exclusivas. Se houver uma duplicação de chaves na estrutura de mapeamento de fluxo, um erro será gerado. A ordem da chave é gerada na árvore de serialização.

Exemplo

Um exemplo de estrutura de mapeamento de fluxo é mostrado abaixo -

%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

A saída da sequência mapeada (lista não ordenada) no formato JSON é mostrada abaixo -

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

Se você observar essa saída conforme mostrado acima, observará que os nomes das chaves são mantidos exclusivos na estrutura de mapeamento YAML.

As sequências de blocos de YAML representam uma série de nós. Cada item é denotado por um indicador “-“ inicial. Observe que o indicador “-“ em YAML deve ser separado do nó com um espaço em branco.

A representação básica da sequência de blocos é fornecida abaixo -

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

Exemplo

Observe os exemplos a seguir para uma melhor compreensão das sequências de blocos.

Exemplo 1

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

A saída das sequências de blocos no formato JSON é fornecida abaixo -

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

Um esquema YAML é definido como uma combinação de um conjunto de tags e inclui um mecanismo para resolver tags não específicas. O esquema à prova de falhas em YAML é criado de maneira que possa ser usado com qualquer documento YAML. Também é considerado um esquema recomendado para um documento YAML genérico.

Tipos

Existem dois tipos de esquema à prova de falhas: Generic Mapping e Generic Sequence

Mapeamento Genérico

Ele representa um contêiner associativo. Aqui, cada chave é única na associação e mapeada para exatamente um valor. YAML não inclui restrições para definições de chave.

Um exemplo para representar o mapeamento genérico é fornecido abaixo -

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

A saída da estrutura de mapeamento genérico no formato JSON é mostrada abaixo -

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

Sequência Genérica

Ele representa um tipo de sequência. Inclui uma coleção indexada por inteiros sequenciais começando com zero. É representado com!!seq tag.

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

A saída para esta sequência genérica de proteção contra falhas

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

O esquema JSON em YAML é considerado o denominador comum da maioria das linguagens de computador modernas. Ele permite a análise de arquivos JSON. É altamente recomendável em YAML que outros esquemas sejam considerados no esquema JSON. A principal razão para isso é que ele inclui uma combinação de valores-chave que são fáceis de usar. As mensagens podem ser codificadas como chave e podem ser usadas como e quando necessário.

O esquema JSON é escalar e carece de um valor. Uma entrada de mapeamento no esquema JSON é representada no formato de algum par de chave e valor em que nulo é tratado como válido.

Exemplo

Um esquema JSON nulo é representado conforme mostrado abaixo -

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

A saída da representação JSON é mencionada abaixo -

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

Exemplo

O exemplo a seguir representa o esquema Boolean JSON -

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

A seguir está a saída para o mesmo no formato JSON -

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

Exemplo

O exemplo a seguir representa o esquema JSON inteiro -

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

Exemplo

As tags no esquema JSON são representadas com o seguinte exemplo -

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 ]

Você pode encontrar a saída JSON conforme mostrado abaixo -

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