YAML - Guía rápida

YAML Ain't Markup Language es un lenguaje de serialización de datos que coincide con las expectativas del usuario sobre los datos. Está diseñado para ser amigable con los humanos y funciona perfectamente con otros lenguajes de programación. Es útil para administrar datos e incluye caracteres imprimibles Unicode. Este capítulo le dará una introducción a YAML y le dará una idea de sus características.

Formato

Considere el texto que se muestra a continuación:

Quick brown fox jumped over the lazy dog.

El texto YAML para esto se representará como se muestra a continuación:

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

Tenga en cuenta que YAML toma el valor en formato de cadena y representa la salida como se mencionó anteriormente.

Ejemplos

Entendamos los formatos en YAML con la ayuda de los siguientes ejemplos:

Considere el siguiente número de punto de "pi", que tiene un valor de 3,1415926. En YAML, se representa como un número flotante como se muestra a continuación:

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

Supongamos que se deben cargar varios valores en una estructura de datos específica como se menciona a continuación:

eggs
ham
spam
French basil salmon terrine

Cuando carga esto en YAML, los valores se toman en una estructura de datos de matriz que es una forma de lista. La salida es la que se muestra a continuación:

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

Caracteristicas

YAML incluye un lenguaje de marcado con una construcción importante para distinguir el lenguaje orientado a datos con el marcado del documento. Los objetivos de diseño y las características de YAML se indican a continuación:

  • Coincide con estructuras de datos nativas de metodología ágil y sus lenguajes como Perl, Python, PHP, Ruby y JavaScript

  • Los datos YAML son portátiles entre lenguajes de programación

  • Incluye modelo de datos consistente

  • Fácilmente legible por humanos

  • Soporta procesamiento unidireccional

  • Facilidad de implementación y uso

Ahora que tiene una idea sobre YAML y sus características, aprendamos sus conceptos básicos con la sintaxis y otras operaciones. Recuerde que YAML incluye un formato estructurado legible por humanos.

Reglas para crear un archivo YAML

Al crear un archivo en YAML, debe recordar las siguientes reglas básicas:

  • YAML distingue entre mayúsculas y minúsculas

  • Los archivos deben tener .yaml como la extensión

  • YAML no permite el uso de pestañas al crear archivos YAML; en su lugar se permiten espacios

Componentes básicos del archivo YAML

Los componentes básicos de YAML se describen a continuación:

Formato de bloque convencional

Este formato de bloque utiliza hyphen+spacepara comenzar un nuevo elemento en una lista específica. Observe el ejemplo que se muestra a continuación:

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

Inline Format

El formato en línea está delimitado con comma and spacey los elementos están incluidos en JSON. Observe el ejemplo que se muestra a continuación:

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

Folded Text

El texto plegado convierte las líneas nuevas en espacios y elimina los espacios en blanco iniciales. Observe el ejemplo que se muestra a continuación:

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

La estructura que sigue todas las convenciones básicas de YAML se muestra a continuación:

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

Sinopsis de los elementos básicos de YAML

  • La sinopsis de los elementos básicos de YAML se proporciona aquí: Los comentarios en YAML comienzan con (#) personaje.

  • Los comentarios deben estar separados de otros tokens por espacios en blanco.

  • La sangría de los espacios en blanco se utiliza para denotar la estructura.

  • Las pestañas no se incluyen como sangría para los archivos YAML.

  • Los miembros de la lista se indican con un guión inicial (-).

  • Los miembros de la lista se incluyen entre corchetes y separados por comas.

  • Las matrices asociativas se representan mediante dos puntos ( : )en el formato de par clave-valor. Están encerrados en llaves{}.

  • Varios documentos con un solo flujo se separan con 3 guiones (---).

  • Los nodos repetidos en cada archivo se indican inicialmente con un ampersand (&) y con un asterisco (*) marcar más tarde.

  • YAML siempre requiere el uso de dos puntos y comas como separadores de lista seguidos de un espacio con valores escalares.

  • Los nodos deben etiquetarse con un signo de exclamación (!) o doble signo de exclamación (!!), seguida de una cadena que se puede expandir en un URI o URL.

La sangría y la separación son dos conceptos principales cuando está aprendiendo cualquier lenguaje de programación. Este capítulo trata en detalle estos dos conceptos relacionados con YAML.

Sangría de YAML

YAML no incluye espacios obligatorios. Además, no es necesario ser coherente. La sangría válida de YAML se muestra a continuación:

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

  • Debe recordar las siguientes reglas al trabajar con sangría en YAML: Los bloques de flujo deben tener al menos algunos espacios con el nivel de bloque actual circundante.

  • El contenido de flujo de YAML abarca varias líneas. El comienzo del contenido de flujo comienza con{ o [.

  • Los elementos de la lista de bloques incluyen la misma sangría que el nivel de bloque circundante porque - se considera parte de la sangría.

Ejemplo de bloque previsto

Observe el siguiente código que muestra la sangría con ejemplos:

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

Separación de cuerdas

Las cadenas se separan mediante una cadena entre comillas dobles. Si escapa de los caracteres de nueva línea en una cadena determinada, se elimina por completo y se traduce en un valor de espacio.

Ejemplo

En este ejemplo, nos hemos centrado en la lista de animales enumerados como una estructura de matriz con el tipo de datos de cadena. Cada nuevo elemento se enumera con un prefijo de guión como se menciona como prefijo.

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

Otro ejemplo para explicar la representación de cadenas en YAML se menciona a continuación.

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 ejemplo se refiere al conjunto de mensajes de error que un usuario puede utilizar con solo mencionar el aspecto clave y obtener los valores en consecuencia. Este patrón de YAML sigue la estructura de JSON que puede ser entendido por el usuario que es nuevo en YAML.

Ahora que se siente cómodo con la sintaxis y los conceptos básicos de YAML, avancemos en sus detalles. En este capítulo, veremos cómo usar comentarios en YAML.

YAML supports single line comments. Su estructura se explica a continuación con la ayuda de un ejemplo:

# this is single line comment.

YAML does not support multi line comments. Si desea proporcionar comentarios para varias líneas, puede hacerlo como se muestra en el siguiente ejemplo:

# this
# is a multiple
# line comment

Características de los comentarios

Las características de los comentarios en YAML se detallan a continuación:

  • Se omite un bloque comentado durante la ejecución.

  • Los comentarios ayudan a agregar una descripción para el bloque de código especificado.

  • Los comentarios no deben aparecer dentro de los escalares.

  • YAML no incluye ninguna forma de escapar del símbolo de almohadilla (#), por lo que dentro de una cadena de varias líneas, no hay forma de dividir el comentario del valor de la cadena sin procesar.

Los comentarios dentro de una colección se muestran a continuación:

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

La combinación de teclas de método abreviado para comentar bloques YAML es Ctrl+Q.

Si esta usando Sublime Text editor, los pasos para comentar el bloque se mencionan a continuación:

Seleccione el bloque. Utilice "CTRL + /" en Linux y Windows y "CMD + /" para el sistema operativo Mac. Ejecuta el bloque.

Tenga en cuenta que los mismos pasos son aplicables si está utilizando Visual Studio Code Editor. Siempre se recomienda utilizarSublime Text Editor para crear archivos YAML, ya que es compatible con la mayoría de los sistemas operativos e incluye teclas de acceso directo fáciles de usar para desarrolladores.

YAML incluye colecciones de bloques que usan sangría para el alcance. Aquí, cada entrada comienza con una nueva línea. Las secuencias de bloques en las colecciones indican cada entrada con undash and space(-). En YAML, los estilos de colecciones de bloques no se indican mediante ningún indicador específico. La colección de bloques en YAML se puede distinguir de otras cantidades escalares con una identificación del par clave-valor incluida en ellas.

Las asignaciones son la representación del valor de clave tal como se incluye en la estructura JSON. Se utiliza a menudo en sistemas de soporte multilingües y creación de API en aplicaciones móviles. Las asignaciones utilizan la representación de pares clave-valor con el uso decolon and space (:).

Ejemplos

Considere un ejemplo de secuencia de escalares, por ejemplo, una lista de jugadores de pelota como se muestra a continuación:

- Mark Joseph
- James Stephen
- Ken Griffey

El siguiente ejemplo muestra la asignación de escalares a escalares:

hr: 87
avg: 0.298
rbi: 149

El siguiente ejemplo muestra la asignación de escalares a secuencias:

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

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

Las colecciones se pueden usar para mapeos de secuencia que se muestran a continuación:

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

Con las colecciones, YAML incluye estilos de flujo que utilizan indicadores explícitos en lugar de utilizar sangrías para denotar el espacio. La secuencia de flujo en las colecciones se escribe como una lista separada por comas encerrada entre corchetes. La mejor ilustración para la colección que se incluye en marcos PHP como Symphony.

[PHP, Perl, Python]

Estas colecciones se almacenan en documentos. La separación de documentos en YAML se indica con tres guiones o guiones (---). El final del documento está marcado con tres puntos (…).

La separación de documentos en YAML se indica con tres guiones (---). El final del documento se representa con tres puntos (…).

La representación del documento se conoce como formato de estructura que se menciona a continuación:

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

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

Un signo de interrogación con una combinación de espacio indica un mapeo complejo en la estructura. Dentro de una colección de bloques, un usuario puede incluir una estructura con un guión, dos puntos y un signo de interrogación. El siguiente ejemplo muestra el mapeo entre secuencias:

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

Los escalares en YAML se escriben en formato de bloque utilizando un tipo literal que se denota como (|). Denota el recuento de saltos de línea. En YAML, los escalares se escriben en estilo plegado (>) donde cada línea denota un espacio plegado que termina con un empty line o more indented línea.

Las nuevas líneas se conservan en literales se muestran a continuación:

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

Las nuevas líneas plegadas se conservan para more indented lines y blank lines como se muestra a continuación -

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

Los escalares de flujo YAML incluyen estilos simples y estilos entre comillas. El estilo entre comillas dobles incluye varias secuencias de escape. Los escalares de flujo pueden incluir múltiples líneas; Los saltos de línea siempre se pliegan en esta estructura.

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

En YAML, los nodos sin etiquetar se especifican con un tipo específico de aplicación. Los ejemplos de especificación de etiquetas generalmente usanseq, map y strtipos para el repositorio de etiquetas YAML. Las etiquetas se representan como ejemplos que se mencionan a continuación:

Etiquetas enteras

Estas etiquetas incluyen valores enteros. También se denominan etiquetas numéricas.

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

Números de punto flotante

Estas etiquetas incluyen valores decimales y exponenciales. También se denominan etiquetas exponenciales.

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

Etiquetas misceláneas

Incluye una variedad de valores enteros, flotantes y de cadena incrustados en ellos. Por eso se llama etiquetas misceláneas.

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

El siguiente ejemplo completo especifica la construcción de YAML que incluye símbolos y varias representaciones que serán útiles al convertirlos o procesarlos en formato JSON. Estos atributos también se denominan nombres clave en documentos JSON. Estas anotaciones se crean por motivos de seguridad.

El formato YAML anterior representa varios atributos de valores predeterminados, adaptador y host con varios otros atributos. YAML también mantiene un registro de cada archivo generado que mantiene un seguimiento de los mensajes de error generados. Al convertir el archivo YAML especificado en formato JSON, obtenemos la salida deseada como se menciona a continuación:

defaults: &defaults
   adapter:  postgres
   host:     localhost

development:
   database: myapp_development
   <<: *defaults

test:
   database: myapp_test
   <<: *defaults

Convirtamos el formato YAML a JSON y verifiquemos la salida.

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

La clave predeterminada con un prefijo de “<<: *” se incluye cuando es necesario sin necesidad de escribir el mismo fragmento de código repetidamente.

YAML sigue un procedimiento estándar para el flujo de procesos. La estructura de datos nativa en YAML incluye representaciones simples como nodos. También se denomina Gráfico de nodo de representación.

Incluye mapeo, secuencia y cantidades escalares que se serializan para crear un árbol de serialización. Con la serialización, los objetos se convierten con un flujo de bytes.

El árbol de eventos de serialización ayuda a crear la presentación de los flujos de caracteres como se representa en el siguiente diagrama.

El procedimiento inverso analiza el flujo de bytes en un árbol de eventos serializado. Posteriormente, los nodos se convierten en gráficos de nodos. Estos valores se convierten posteriormente en la estructura de datos nativa YAML. La siguiente figura explica esto:

La información en YAML se usa de dos formas: machine processing y human consumption. El procesador en YAML se utiliza como una herramienta para el procedimiento de conversión de información entre vistas complementarias en el diagrama dado arriba. Este capítulo describe las estructuras de información que un procesador YAML debe proporcionar dentro de una aplicación determinada.

YAML incluye un procedimiento de serialización para representar objetos de datos en formato serial. El procesamiento de la información YAML incluye tres etapas:Representation, Serialization, Presentation and parsing. Analicemos cada uno de ellos en detalle.

Representación

YAML representa la estructura de datos utilizando tres tipos de nodos: sequence, mapping y scalar.

Secuencia

La secuencia se refiere al número ordenado de entradas, que mapea la asociación desordenada del par clave-valor. Corresponde a la lista de matrices de Perl o Python.

El código que se muestra a continuación es un ejemplo de representación de secuencia:

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

Cartografía

El mapeo, por otro lado, representa la estructura de datos del diccionario o la tabla hash. Un ejemplo de lo mismo se menciona a continuación:

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

Escalares

Los escalares representan valores estándar de cadenas, números enteros, fechas y tipos de datos atómicos. Tenga en cuenta que YAML también incluye nodos que especifican la estructura del tipo de datos. Para obtener más información sobre escalares, consulte el capítulo 6 de este tutorial.

Publicación por entregas

Se requiere un proceso de serialización en YAML que facilita el orden de claves y los nombres de ancla amigables para los humanos. El resultado de la serialización es un árbol de serialización YAML. Se puede atravesar para producir una serie de llamadas a eventos de datos YAML.

A continuación se ofrece un ejemplo de serialización:

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

Presentación

La salida final de la serialización YAML se llama presentación. Representa una corriente de personajes de una manera amigable con los humanos. El procesador YAML incluye varios detalles de presentación para crear flujos, manejar sangrías y formatear contenido. Este proceso completo está guiado por las preferencias del usuario.

Un ejemplo de proceso de presentación YAML es el resultado del valor JSON creado. Observe el código que se proporciona a continuación para una mejor comprensión:

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

Analizando

El análisis es el proceso inverso de presentación; incluye un flujo de personajes y crea una serie de eventos. Descarta los detalles introducidos en el proceso de presentación que provocan eventos de serialización. El procedimiento de análisis puede fallar debido a una entrada mal formada. Básicamente es un procedimiento para comprobar si YAML está bien formado o no.

Considere un ejemplo de YAML que se menciona a continuación:

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

Con tres guiones, representa el inicio del documento con varios atributos definidos posteriormente en él.

YAML lint es el analizador en línea de YAML y ayuda a analizar la estructura YAML para verificar si es válida o no. El enlace oficial de YAML lint se menciona a continuación:http://www.yamllint.com/

Puede ver el resultado del análisis como se muestra a continuación:

Este capítulo explicará en detalle los procedimientos y procesos que discutimos en el capítulo anterior. Los modelos de información en YAML especificarán las características del procedimiento de serialización y presentación en un formato sistemático utilizando un diagrama específico.

Para un modelo de información, es importante representar la información de la aplicación que es portátil entre entornos de programación.

El diagrama que se muestra arriba representa un modelo de información normal que se representa en formato de gráfico. En YAML, la representación de datos nativos está enraizada, conectada y es un gráfico dirigido de nodos etiquetados. Si mencionamos grafo dirigido, incluye un conjunto de nodos con grafo dirigido. Como se menciona en el modelo de información, YAML admite tres tipos de nodos, a saber:

  • Sequences
  • Scalars
  • Mappings

Las definiciones básicas de estos nodos de representación se discutieron en el último capítulo. En este capítulo, nos centraremos en la vista esquemática de estos términos. El siguiente diagrama de secuencia representa el flujo de trabajo de leyendas con varios tipos de etiquetas y nodos de mapeo.

Hay tres tipos de nodos: sequence node, scalar node y mapping node.

Secuencias

El nodo de secuencia sigue una arquitectura secuencial e incluye una serie ordenada de cero o más nodos. Una secuencia YAML puede contener el mismo nodo repetidamente o un solo nodo.

Escalares

El contenido de escalares en YAML incluye caracteres Unicode que se pueden representar en el formato con una serie de cero. En general, el nodo escalar incluye cantidades escalares.

Cartografía

El nodo de mapeo incluye la representación del par clave-valor. El contenido del nodo de mapeo incluye una combinación de par clave-valor con una condición obligatoria de que el nombre de clave debe mantenerse único. Las secuencias y mapeos forman colectivamente una colección.

Tenga en cuenta que, como se representa en el diagrama que se muestra arriba, los escalares, las secuencias y las asignaciones se representan en un formato sistemático.

Se utilizan varios tipos de caracteres para diversas funcionalidades. Este capítulo habla en detalle sobre la sintaxis usada en YAML y se enfoca en la manipulación de caracteres.

Caracteres indicadores

Los caracteres indicadores incluyen una semántica especial que se utiliza para describir el contenido del documento YAML. La siguiente tabla muestra esto en detalle.

No Señor. Carácter y funcionalidad
1

_

Denota una entrada de secuencia de bloque
2

?

Denota una clave de mapeo
3

:

Denota un valor de mapeo
4

,

Denota entrada de colección de flujo
5

[

Inicia una secuencia de flujo
6

]

Termina una secuencia de flujo
7

{

Inicia un mapeo de flujo
8

}

Termina un mapeo de flujo
9

#

Denota los comentarios
10

&

Denota la propiedad de anclaje del nodo
11

*

Denota nodo de alias
12

!

Denota la etiqueta del nodo
13

|

Denota un escalar de bloque literal
14

>

Denota un escalar de bloque plegado
15

`

La comilla simple rodea un escalar de flujo entre comillas
dieciséis

"

La comilla doble rodea el escalar de flujo entre comillas dobles
17

%

Denota la directiva utilizada

El siguiente ejemplo muestra los caracteres utilizados en la sintaxis:

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

En este capítulo, aprenderá sobre los siguientes aspectos de las primitivas de sintaxis en YAML:

  • Parámetros de producción
  • Espacios de sangría
  • Espacios de separación
  • Prefijo de línea ignorado
  • Línea plegable

Entendamos cada aspecto en detalle.

Parámetros de producción

Los parámetros de producción incluyen un conjunto de parámetros y el rango de valores permitidos que se utilizan en una producción específica. La siguiente lista de parámetros de producción se utiliza en YAML:

Sangría

Se denota por carácter n o mEl flujo de caracteres depende del nivel de sangría de los bloques incluidos en él. Muchas producciones han parametrizado estas características.

Contexto

Se denota por c. YAML admite dos grupos de contextos:block styles y flow styles.

Estilo

Se denota por s. El contenido escalar se puede presentar en uno de los cinco estilos:plain, double quoted and single quoted flow, literal and folded block.

Masticando

Se denota por t. Los escalares de bloque ofrecen muchos mecanismos que ayudan a recortar el bloque:strip, clip y keep. Chomping ayuda a formatear nuevas cadenas de línea. Se utiliza la representación de estilo de bloque. El proceso de masticación ocurre con la ayuda de indicadores. Los indicadores controlan qué salida debe producirse con nuevas líneas de cuerda. Las nuevas líneas se eliminan con(-) operador y nuevas líneas se agregan con (+) operador.

A continuación se muestra un ejemplo de proceso de masticación:

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

La salida después de analizar el ejemplo de YAML especificado es la siguiente:

Espacios de sangría

En el flujo de caracteres YAML, la sangría se define como un carácter de salto de línea por cero o más caracteres. El punto más importante a tener en cuenta es que la sangría no debe contener caracteres de tabulación. Los caracteres en sangría nunca deben considerarse como parte de la información de contenido del nodo. Observe el siguiente código para una mejor comprensión:

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

La salida que puede ver después de la sangría es la siguiente:

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

Espacios de separación

YAML usa caracteres de espacio para la separación entre tokens. La nota más importante es que la separación en YAML no debe contener tabulaciones.

El siguiente código muestra el uso de espacios de separación:

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

Prefijo de línea ignorado

El prefijo vacío siempre incluye sangría dependiendo del tipo escalar que también incluye un espacio en blanco inicial. Los escalares simples no deben contener caracteres de tabulación. Por otro lado, los escalares entre comillas pueden contener tabulaciones. Los escalares de bloque dependen completamente de la sangría.

El siguiente ejemplo muestra el funcionamiento del prefijo de línea ignorado de manera sistemática:

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

La salida lograda para los flujos de bloques es la siguiente:

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

Línea plegable

El plegado de líneas permite romper líneas largas para facilitar la lectura. Más cantidades de líneas cortas significan una mejor legibilidad. El plegado de la línea se logra observando la semántica original de la línea larga. El siguiente ejemplo demuestra el plegado de líneas:

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

Puede ver el resultado del plegado de líneas en formato JSON de la siguiente manera:

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

En YAML, te encuentras con varios flujos de personajes de la siguiente manera:

  • Directives
  • Marcadores de límites de documentos
  • Documents
  • Transmisión completa

En este capítulo, los discutiremos en detalle.

Directivas

Las directivas son instrucciones básicas que se utilizan en el procesador YAML. Las directivas son los detalles de la presentación, como los comentarios, que no se reflejan en el árbol de serialización. En YAML, no hay forma de definir directivas privadas. Esta sección analiza varios tipos de directivas con ejemplos relevantes:

Directivas reservadas

Las directivas reservadas se inicializan con tres guiones (---) como se muestra en el siguiente ejemplo. Las directivas reservadas se convierten en un valor específico de JSON.

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

Directiva YAML

Las directivas YAML son directivas predeterminadas. Si se convierte en JSON, el valor obtenido incluye el carácter de barra inclinada en los caracteres anteriores y finales.

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

Marcadores de límites de documentos

YAML usa estos marcadores para permitir que más de un documento esté contenido en una secuencia. Estos marcadores se utilizan especialmente para transmitir la estructura del documento YAML. Tenga en cuenta que una línea que comienza con "---" se utiliza para iniciar un nuevo documento.

El siguiente código explica esto con ejemplos:

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

Documentos

El documento YAML se considera como una única estructura de datos nativa presentada como un solo nodo raíz. Los detalles de la presentación en el documento YAML como directivas, comentarios, sangría y estilos no se consideran contenidos incluidos en ellos.

Hay dos tipos de documentos que se utilizan en YAML. Se explican en esta sección:

Documentos explícitos

Comienza con el marcador de inicio del documento seguido de la presentación del nodo raíz. El ejemplo de declaración explícita YAML se da a continuación:

---

some: yaml

...

Incluye marcadores explícitos de inicio y finalización que son "---" y "..." en el ejemplo dado. Al convertir el YAML especificado en formato JSON, obtenemos el resultado como se muestra a continuación:

{
   "some": "yaml"
}

Documentos implícitos

Estos documentos no comienzan con un marcador de inicio de documento. Observe el código que se proporciona a continuación:

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

Al convertir estos valores en formato JSON, obtenemos la salida como un objeto JSON simple como se indica a continuación:

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

Transmisión completa

YAML incluye una secuencia de bytes denominada flujo de caracteres. La secuencia comienza con un prefijo que contiene un orden de bytes que denota una codificación de caracteres. El flujo completo comienza con un prefijo que contiene una codificación de caracteres, seguido de comentarios.

A continuación se muestra un ejemplo de flujo completo (flujo de caracteres):

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

Cada nodo de presentación incluye dos características principales llamadas anchor y tag. Las propiedades del nodo se pueden especificar con el contenido del nodo, omitido del flujo de caracteres.

El ejemplo básico de representación de un nodo es el siguiente:

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

Anclajes de nodo

La propiedad de anclaje representa un nodo para referencia futura. El flujo de caracteres de la representación YAML en el nodo se denota con elampersand (&)indicador. El procesador YAML no necesita conservar el nombre del ancla con los detalles de representación compuestos en él. El siguiente código explica esto:

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

La salida de YAML generado con nodos de anclaje se muestra a continuación:

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

Etiquetas de nodo

La propiedad de la etiqueta representa el tipo de estructura de datos nativa que define un nodo por completo. Una etiqueta se representa con (!) indicador. Las etiquetas se consideran una parte inherente del gráfico de representación. El siguiente ejemplo de explica las etiquetas de nodo en detalle:

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

Contenido de nodo

El contenido del nodo se puede representar en un contenido de flujo o en un formato de bloque. El contenido del bloque se extiende hasta el final de la línea y usa sangría para denotar estructura. Cada tipo de colección se puede representar en un estilo de colección de flujo único específico o se puede considerar como un solo bloque. El siguiente código explica esto en detalle:

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

En este capítulo, nos centraremos en varios tipos escalares que se utilizan para representar el contenido. En YAML, los comentarios pueden preceder o seguir al contenido escalar. Es importante tener en cuenta que los comentarios no deben incluirse dentro del contenido escalar.

Tenga en cuenta que todos los estilos escalares de flujo pueden incluir varias líneas, excepto con el uso en varias claves.

La representación de los escalares se da a continuación:

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

La salida generada de los encabezados escalares de bloque se muestra a continuación:

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

Contenido escalar del marcador de documento

Todos los caracteres de este ejemplo se consideran contenido, incluidos los caracteres de espacio interior.

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

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

Los saltos de línea simples se representan con el ejemplo que se muestra a continuación:

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

La salida JSON correspondiente para el mismo se menciona a continuación:

"as space trimmed\nspecific\u2028\nnone"

Los estilos de flujo en YAML se pueden considerar como una extensión natural de JSON para cubrir las líneas de contenido plegables para una función mejor legible que utiliza anclajes y alias para crear las instancias de objeto. En este capítulo, nos centraremos en la representación de flujo de los siguientes conceptos:

  • Nodos de alias
  • Nodos vacíos
  • Estilos escalares de flujo
  • Estilos de colección de flujo
  • Nodos de flujo

El ejemplo de nodos de alias se muestra a continuación:

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

La salida JSON del código dado arriba se da a continuación:

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

Los nodos con contenido vacío se consideran nodos vacíos. El siguiente ejemplo muestra esto:

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

La salida de los nodos vacíos en JSON se representa a continuación:

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

Los estilos escalares de flujo incluyen tipos de comillas dobles, comillas simples y simples. El ejemplo básico para el mismo se da a continuación:

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

La salida en formato JSON para el ejemplo anterior se muestra a continuación:

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

La colección de flujo en YAML está anidada con una colección de bloques dentro de otra colección de flujo. Las entradas de colección de flujo terminan concomma (,) indicador. El siguiente ejemplo explica el bloque de recolección de flujo en detalle:

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

La salida para la recopilación de flujo en JSON se muestra a continuación:

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

Los estilos de flujo como JSON incluyen indicadores de inicio y finalización. El único estilo de flujo que no tiene ninguna propiedad es el escalar simple.

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

La salida para el código que se muestra arriba en formato JSON se da a continuación:

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

YAML incluye dos estilos escalares de bloque: literal y folded. Los escalares de bloque se controlan con pocos indicadores con un encabezado que precede al contenido en sí. A continuación se muestra un ejemplo de encabezados escalares de bloque:

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

La salida en formato JSON con un comportamiento predeterminado se muestra a continuación:

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

Tipos de estilos de bloque

Hay cuatro tipos de estilos de bloque: literal, folded, keep y stripestilos. Estos estilos de bloque se definen con la ayuda del escenario Block Chomping. A continuación se muestra un ejemplo de un escenario de masticación de bloques:

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

Puede ver la salida generada con tres formatos en JSON como se indica a continuación:

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

Masticar en YAML controla los saltos finales y las líneas vacías finales que se interpretan de varias formas.

Pelar

En este caso, el salto de línea final y las líneas vacías se excluyen del contenido escalar. Se especifica mediante el indicador de masticación "-".

Recorte

El recorte se considera un comportamiento predeterminado si no se especifica un indicador de masticación explícito. El carácter de ruptura final se conserva en el contenido del escalar. El mejor ejemplo de recorte se muestra en el ejemplo anterior. Termina con nueva línea“\n” personaje.

Acuerdo

Mantener se refiere a la adición con la representación del indicador de masticación "+". Las líneas adicionales creadas no están sujetas a plegado. Las líneas adicionales no están sujetas a plegado.

Para comprender los estilos de secuencia, es importante comprender las colecciones. El concepto de colecciones y estilos de secuencia funcionan en paralelo. La colección en YAML se representa con los estilos de secuencia adecuados. Si desea consultar la secuencia adecuada de etiquetas, siempre consulte las colecciones. Las colecciones en YAML están indexadas por enteros secuenciales que comienzan con cero como se representa en matrices. El enfoque de los estilos de secuencia comienza con las colecciones.

Ejemplo

Consideremos el número de planetas en el universo como una secuencia que se puede crear como una colección. El siguiente código muestra cómo representar los estilos de secuencia de planetas en el 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

Luego, puede ver la siguiente salida para la secuencia ordenada en formato JSON:

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

Las asignaciones de flujo en YAML representan la colección desordenada de pares clave-valor. También se denominan nodo de mapeo. Tenga en cuenta que las claves deben mantenerse únicas. Si hay una duplicación de claves en la estructura de mapeo de flujo, generará un error. El orden de las claves se genera en el árbol de serialización.

Ejemplo

A continuación se muestra un ejemplo de estructura de mapeo de flujo:

%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

La salida de la secuencia mapeada (lista desordenada) en formato JSON es como se muestra a continuación:

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

Si observa este resultado como se muestra arriba, se observa que los nombres de clave se mantienen únicos en la estructura de mapeo YAML.

Las secuencias de bloques de YAML representan una serie de nodos. Cada elemento se indica con un indicador "-" inicial. Tenga en cuenta que el indicador "-" en YAML debe estar separado del nodo con un espacio en blanco.

La representación básica de la secuencia de bloques se da a continuación:

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

Ejemplo

Observe los siguientes ejemplos para comprender mejor las secuencias de bloques.

Ejemplo 1

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

La salida de las secuencias de bloques en formato JSON se muestra a continuación:

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

Un esquema YAML se define como una combinación de un conjunto de etiquetas e incluye un mecanismo para resolver etiquetas no específicas. El esquema a prueba de fallos en YAML se crea de tal manera que se puede utilizar con cualquier documento YAML. También se considera un esquema recomendado para un documento YAML genérico.

Tipos

Hay dos tipos de esquema a prueba de fallos: Generic Mapping y Generic Sequence

Mapeo genérico

Representa un contenedor asociativo. Aquí, cada clave es única en la asociación y se asigna exactamente a un valor. YAML no incluye restricciones para las definiciones de claves.

A continuación se muestra un ejemplo para representar un mapeo genérico:

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

La salida de la estructura de mapeo genérica en formato JSON se muestra a continuación:

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

Secuencia genérica

Representa un tipo de secuencia. Incluye una colección indexada por enteros secuenciales que comienzan con cero. Está representado con!!seq etiqueta.

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

El resultado de esta secuencia genérica de seguridad

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

El esquema JSON en YAML se considera el denominador común de la mayoría de los lenguajes informáticos modernos. Permite analizar archivos JSON. Se recomienda encarecidamente en YAML que se consideren otros esquemas en el esquema JSON. La razón principal de esto es que incluye una combinación de valores clave que son fáciles de usar. Los mensajes se pueden codificar como clave y se pueden utilizar cuando sea necesario.

El esquema JSON es escalar y carece de valor. Una entrada de mapeo en el esquema JSON se representa en el formato de algún par de clave y valor donde nulo se trata como válido.

Ejemplo

Un esquema JSON nulo se representa como se muestra a continuación:

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

La salida de la representación JSON se menciona a continuación:

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

Ejemplo

El siguiente ejemplo representa el esquema JSON booleano:

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

La siguiente es la salida para el mismo en formato JSON:

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

Ejemplo

El siguiente ejemplo representa el esquema JSON entero:

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

Ejemplo

Las etiquetas en el esquema JSON se representan con el siguiente ejemplo:

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 ]

Puede encontrar la salida JSON como se muestra a continuación:

{
   "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"
   ]
}
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved