YAML - Guida rapida

YAML Ain't Markup Language è un linguaggio di serializzazione dei dati che soddisfa le aspettative dell'utente sui dati. È progettato per essere umano e funziona perfettamente con altri linguaggi di programmazione. È utile per gestire i dati e include caratteri stampabili Unicode. Questo capitolo ti darà un'introduzione a YAML e ti darà un'idea delle sue caratteristiche.

Formato

Considera il testo mostrato di seguito -

Quick brown fox jumped over the lazy dog.

Il testo YAML per questo sarà rappresentato come mostrato di seguito -

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

Nota che YAML prende il valore in formato stringa e rappresenta l'output come menzionato sopra.

Esempi

Cerchiamo di capire i formati in YAML con l'aiuto dei seguenti esempi:

Considera il seguente numero di punto di "pi", che ha un valore di 3,1415926. In YAML, è rappresentato come un numero mobile come mostrato di seguito -

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

Supponiamo di dover caricare più valori in una struttura dati specifica come indicato di seguito:

eggs
ham
spam
French basil salmon terrine

Quando lo carichi in YAML, i valori vengono presi in una struttura dati ad array che è una forma di lista. L'output è come mostrato di seguito:

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

Caratteristiche

YAML include un linguaggio di markup con costrutti importanti, per distinguere il linguaggio orientato ai dati con il markup del documento. Gli obiettivi di progettazione e le caratteristiche di YAML sono riportati di seguito:

  • Corrisponde alle strutture di dati native della metodologia agile e dei suoi linguaggi come Perl, Python, PHP, Ruby e JavaScript

  • I dati YAML sono trasferibili tra i linguaggi di programmazione

  • Include un modello di dati coerente con i dati

  • Facilmente leggibile dagli esseri umani

  • Supporta l'elaborazione unidirezionale

  • Facilità di implementazione e utilizzo

Ora che hai un'idea di YAML e delle sue caratteristiche, impariamo le sue basi con la sintassi e altre operazioni. Ricorda che YAML include un formato strutturato leggibile dall'uomo.

Regole per la creazione del file YAML

Quando crei un file in YAML, dovresti ricordare le seguenti regole di base:

  • YAML distingue tra maiuscole e minuscole

  • I file dovrebbero avere .yaml come estensione

  • YAML non consente l'uso di schede durante la creazione di file YAML; gli spazi sono invece consentiti

Componenti di base del file YAML

I componenti di base di YAML sono descritti di seguito:

Formato blocco convenzionale

Questo formato di blocco utilizza hyphen+spaceper iniziare un nuovo elemento in un elenco specificato. Osservare l'esempio mostrato di seguito:

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

Inline Format

Il formato inline è delimitato da comma and spacee gli elementi sono racchiusi in JSON. Osservare l'esempio mostrato di seguito:

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

Folded Text

Il testo piegato converte le nuove righe in spazi e rimuove gli spazi bianchi iniziali. Osservare l'esempio mostrato di seguito:

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

Di seguito viene mostrata la struttura che segue tutte le convenzioni di base di YAML:

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

Sinossi di YAML Basic Elements

  • La sinossi degli elementi di base di YAML è fornita qui: I commenti in YAML iniziano con (#) personaggio.

  • I commenti devono essere separati dagli altri token da spazi bianchi.

  • Il rientro degli spazi bianchi è usato per denotare la struttura.

  • Le tabulazioni non sono incluse come rientro per i file YAML.

  • I membri dell'elenco sono indicati da un trattino iniziale (-).

  • I membri dell'elenco sono racchiusi tra parentesi quadre e separati da virgole.

  • Gli array associativi sono rappresentati utilizzando i due punti ( : )nel formato della coppia chiave-valore. Sono racchiusi tra parentesi graffe{}.

  • Più documenti con flussi singoli sono separati da 3 trattini (---).

  • I nodi ripetuti in ogni file sono inizialmente indicati da una e commerciale (&) e da un asterisco (*) contrassegna più tardi.

  • YAML richiede sempre due punti e virgole usati come separatori di elenco seguiti da spazi con valori scalari.

  • I nodi dovrebbero essere etichettati con un punto esclamativo (!) o doppio punto esclamativo (!!), seguito da una stringa che può essere espansa in un URI o URL.

Il rientro e la separazione sono due concetti principali quando impari qualsiasi linguaggio di programmazione. Questo capitolo parla in dettaglio di questi due concetti relativi a YAML.

Rientro di YAML

YAML non include spazi obbligatori. Inoltre, non è necessario essere coerenti. Il rientro YAML valido è mostrato di seguito:

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

  • Dovresti ricordare le seguenti regole mentre lavori con l'indentazione in YAML: I blocchi di flusso devono essere intesi con almeno alcuni spazi con il livello di blocco corrente circostante.

  • Il contenuto di flusso di YAML si estende su più righe. L'inizio del contenuto del flusso inizia con{ o [.

  • Gli elementi dell'elenco di blocco includono lo stesso rientro del livello di blocco circostante perché - è considerato come parte del rientro.

Esempio di blocco previsto

Osserva il codice seguente che mostra il rientro con esempi:

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

Separazione di stringhe

Le stringhe vengono separate utilizzando una stringa tra virgolette. Se esegui l'escape dei caratteri di nuova riga in una determinata stringa, viene completamente rimosso e tradotto in valore di spazio.

Esempio

In questo esempio abbiamo focalizzato un elenco di animali elencati come una struttura di array con tipo di dati stringa. Ogni nuovo elemento è elencato con un prefisso di trattino come indicato come prefisso.

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

Un altro esempio per spiegare la rappresentazione delle stringhe in YAML è menzionato di seguito.

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

Questo esempio si riferisce alla serie di messaggi di errore che un utente può utilizzare menzionando semplicemente l'aspetto chiave e per recuperare i valori di conseguenza. Questo modello di YAML segue la struttura di JSON che può essere compresa dall'utente che è nuovo in YAML.

Ora che sei a tuo agio con la sintassi e le basi di YAML, procediamo ulteriormente nei suoi dettagli. In questo capitolo vedremo come utilizzare i commenti in YAML.

YAML supports single line comments. La sua struttura è spiegata di seguito con l'aiuto di un esempio:

# this is single line comment.

YAML does not support multi line comments. Se desideri fornire commenti per più righe, puoi farlo come mostrato nell'esempio seguente:

# this
# is a multiple
# line comment

Caratteristiche dei commenti

Le caratteristiche dei commenti in YAML sono riportate di seguito:

  • Un blocco commentato viene saltato durante l'esecuzione.

  • I commenti aiutano ad aggiungere una descrizione per il blocco di codice specificato.

  • I commenti non devono apparire all'interno degli scalari.

  • YAML non include alcun modo per sfuggire al simbolo cancelletto (#) quindi all'interno di una stringa multilinea quindi non c'è modo di dividere il commento dal valore della stringa non elaborata.

I commenti all'interno di una raccolta sono mostrati di seguito:

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

La combinazione di tasti di scelta rapida per commentare i blocchi YAML è Ctrl+Q.

Se stai usando Sublime Text editor, i passaggi per commentare il blocco sono indicati di seguito:

Seleziona il blocco. Utilizzare "CTRL + /" su Linux e Windows e "CMD + /" per il sistema operativo Mac. Esegui il blocco.

Notare che gli stessi passaggi sono applicabili se si utilizza Visual Studio Code Editor. Si consiglia sempre di utilizzareSublime Text Editor per la creazione di file YAML in quanto supportato dalla maggior parte dei sistemi operativi e include tasti di scelta rapida per sviluppatori.

YAML include raccolte di blocchi che utilizzano l'indentazione per l'ambito. Ogni voce inizia con una nuova riga. Le sequenze di blocchi nelle raccolte indicano ogni voce con undash and space(-). In YAML, gli stili delle raccolte di blocchi non sono indicati da alcun indicatore specifico. La raccolta di blocchi in YAML può essere distinta da altre quantità scalari con un'identificazione della coppia di valori chiave inclusa in esse.

Le mappature sono la rappresentazione del valore chiave incluso nella struttura JSON. Viene spesso utilizzato nei sistemi di supporto multilingue e nella creazione di API nelle applicazioni mobili. Le mappature utilizzano la rappresentazione della coppia di valori chiave con l'utilizzo dicolon and space (:).

Esempi

Considera un esempio di sequenza di scalari, ad esempio un elenco di giocatori di palla come mostrato di seguito:

- Mark Joseph
- James Stephen
- Ken Griffey

L'esempio seguente mostra la mappatura degli scalari in scalari:

hr: 87
avg: 0.298
rbi: 149

L'esempio seguente mostra la mappatura degli scalari alle sequenze:

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

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

Le raccolte possono essere utilizzate per le mappature di sequenza mostrate di seguito:

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

Con le raccolte, YAML include stili di flusso utilizzando indicatori espliciti invece di utilizzare il rientro per denotare lo spazio. La sequenza di flusso nelle raccolte viene scritta come elenco separato da virgole racchiuso tra parentesi quadre. La migliore illustrazione per la raccolta che è inclusa nei framework PHP come symphony.

[PHP, Perl, Python]

Queste raccolte vengono archiviate nei documenti. La separazione dei documenti in YAML è indicata con tre trattini o trattini (---). La fine del documento è contrassegnata da tre punti (…).

La separazione dei documenti in YAML è indicata da tre trattini (---). La fine del documento è rappresentata da tre punti (…).

La rappresentazione del documento è indicata come formato di struttura menzionato di seguito:

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

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

Un punto interrogativo con una combinazione di spazio indica una complessa mappatura nella struttura. All'interno di una raccolta di blocchi, un utente può includere una struttura con un trattino, due punti e un punto interrogativo. L'esempio seguente mostra la mappatura tra le sequenze:

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

Gli scalari in YAML vengono scritti in formato blocco utilizzando un tipo letterale che è indicato come (|). Indica il conteggio delle interruzioni di riga. In YAML, gli scalari sono scritti in stile piegato (>) dove ogni linea denota uno spazio piegato che termina con un empty line o more indented linea.

Le nuove righe sono conservate in letterali sono mostrate di seguito:

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

Le nuove righe piegate vengono conservate per more indented lines e blank lines come mostrato di seguito -

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

Gli scalari di flusso YAML includono stili semplici e stili quotati. Lo stile con virgolette doppie include varie sequenze di escape. Gli scalari di flusso possono includere più linee; le interruzioni di riga sono sempre piegate in questa struttura.

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

In YAML, i nodi senza tag vengono specificati con un tipo specifico di applicazione. Gli esempi di specifica dei tag generalmente vengono utilizzatiseq, map e strtipi per il repository di tag YAML. I tag sono rappresentati come esempi che sono menzionati come di seguito:

Tag interi

Questi tag includono valori interi al loro interno. Sono anche chiamati tag numerici.

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

Numeri in virgola mobile

Questi tag includono valori decimali ed esponenziali. Sono anche chiamati tag esponenziali.

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

Tag vari

Include una varietà di valori interi, floating e stringa incorporati in essi. Quindi è chiamato tag miscellaneo.

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

Il seguente esempio a figura intera specifica il costrutto di YAML che include simboli e varie rappresentazioni che saranno utili durante la conversione o l'elaborazione in formato JSON. Questi attributi vengono anche chiamati come nomi di chiavi nei documenti JSON. Queste annotazioni vengono create per motivi di sicurezza.

Il formato YAML di cui sopra rappresenta vari attributi di default, adattatore e host con vari altri attributi. YAML mantiene anche un registro di ogni file generato che mantiene una traccia dei messaggi di errore generati. Convertendo il file YAML specificato in formato JSON, otteniamo un output desiderato come indicato di seguito -

defaults: &defaults
   adapter:  postgres
   host:     localhost

development:
   database: myapp_development
   <<: *defaults

test:
   database: myapp_test
   <<: *defaults

Convertiamo il formato YAML in JSON e controlliamo l'output.

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

La chiave di default con un prefisso "<<: *" viene inclusa come e quando richiesto senza bisogno di scrivere ripetutamente lo stesso frammento di codice.

YAML segue una procedura standard per il flusso di processo. La struttura dati nativa in YAML include rappresentazioni semplici come i nodi. È anche chiamato grafico del nodo di rappresentazione.

Comprende mappatura, sequenza e quantità scalari che vengono serializzate per creare un albero di serializzazione. Con la serializzazione gli oggetti vengono convertiti con un flusso di byte.

L'albero degli eventi di serializzazione aiuta a creare la presentazione dei flussi di caratteri come rappresentato nel diagramma seguente.

La procedura inversa analizza il flusso di byte nell'albero degli eventi serializzato. Successivamente, i nodi vengono convertiti in grafo dei nodi. Questi valori vengono successivamente convertiti nella struttura dati nativa YAML. La figura seguente spiega questo:

Le informazioni in YAML vengono utilizzate in due modi: machine processing e human consumption. Il processore in YAML viene utilizzato come strumento per la procedura di conversione delle informazioni tra viste complementari nel diagramma sopra riportato. Questo capitolo descrive le strutture informative che un processore YAML deve fornire all'interno di una data applicazione.

YAML include una procedura di serializzazione per rappresentare oggetti di dati in formato seriale. L'elaborazione delle informazioni YAML comprende tre fasi:Representation, Serialization, Presentation and parsing. Cerchiamo di discutere ciascuno di essi in dettaglio.

Rappresentazione

YAML rappresenta la struttura dei dati utilizzando tre tipi di nodi: sequence, mapping e scalar.

Sequenza

La sequenza si riferisce al numero ordinato di voci, che mappa l'associazione non ordinata della coppia chiave-valore. Corrisponde all'elenco di array Perl o Python.

Il codice mostrato di seguito è un esempio di rappresentazione in sequenza:

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

Mappatura

La mappatura invece rappresenta la struttura dei dati del dizionario o la tabella hash. Un esempio per lo stesso è menzionato di seguito:

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

Scalari

Gli scalari rappresentano i valori standard di stringhe, numeri interi, date e tipi di dati atomici. Notare che YAML include anche nodi che specificano la struttura del tipo di dati. Per ulteriori informazioni sugli scalari, fare riferimento al capitolo 6 di questo tutorial.

Serializzazione

Il processo di serializzazione è richiesto in YAML che semplifica l'ordine delle chiavi e i nomi degli ancoraggi. Il risultato della serializzazione è un albero di serializzazione YAML. Può essere attraversato per produrre una serie di chiamate di eventi di dati YAML.

Di seguito viene fornito un esempio di serializzazione:

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

Presentazione

L'output finale della serializzazione YAML è chiamato presentazione. Rappresenta un flusso di personaggi in un modo umano amichevole. Il processore YAML include vari dettagli di presentazione per la creazione di stream, la gestione del rientro e la formattazione del contenuto. Questo processo completo è guidato dalle preferenze dell'utente.

Un esempio per il processo di presentazione YAML è il risultato del valore JSON creato. Osservare il codice fornito di seguito per una migliore comprensione -

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

Analisi

L'analisi è il processo inverso di presentazione; include un flusso di personaggi e crea una serie di eventi. Elimina i dettagli introdotti nel processo di presentazione che causa eventi di serializzazione. La procedura di analisi può non riuscire a causa di un input mal formato. È fondamentalmente una procedura per verificare se YAML è ben formato o meno.

Considera un esempio YAML menzionato di seguito:

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

Con tre trattini, rappresenta l'inizio del documento con vari attributi successivamente definiti in esso.

YAML lint è il parser online di YAML e aiuta ad analizzare la struttura YAML per verificare se è valida o meno. Il link ufficiale per YAML lint è menzionato di seguito:http://www.yamllint.com/

Puoi vedere l'output dell'analisi come mostrato di seguito:

Questo capitolo spiegherà i dettagli sulle procedure e sui processi che abbiamo discusso nel capitolo precedente. I modelli informativi in ​​YAML specificheranno le caratteristiche della serializzazione e la procedura di presentazione in un formato sistematico utilizzando un diagramma specifico.

Per un modello di informazioni, è importante rappresentare le informazioni sull'applicazione che sono portabili tra gli ambienti di programmazione.

Il diagramma mostrato sopra rappresenta un normale modello di informazione rappresentato in formato grafico. In YAML, la rappresentazione dei dati nativi è radicata, connessa ed è un grafico diretto dei nodi contrassegnati. Se citiamo il grafo diretto, include un insieme di nodi con il grafo diretto. Come accennato nel modello informativo, YAML supporta tre tipi di nodi:

  • Sequences
  • Scalars
  • Mappings

Le definizioni di base di questi nodi di rappresentazione sono state discusse nell'ultimo capitolo. In questo capitolo ci concentreremo sulla visione schematica di questi termini. Il seguente diagramma di sequenza rappresenta il flusso di lavoro delle legende con vari tipi di tag e nodi di mappatura.

Esistono tre tipi di nodi: sequence node, scalar node e mapping node.

Sequenze

Il nodo sequenza segue un'architettura sequenziale e include una serie ordinata di zero o più nodi. Una sequenza YAML può contenere lo stesso nodo ripetutamente o un singolo nodo.

Scalari

Il contenuto degli scalari in YAML include caratteri Unicode che possono essere rappresentati nel formato con una serie di zero. In generale, il nodo scalare include quantità scalari.

Mappatura

Il nodo di mappatura include la rappresentazione della coppia di valori chiave. Il contenuto del nodo di mappatura include una combinazione di coppia chiave-valore con una condizione obbligatoria secondo cui il nome della chiave deve essere mantenuto univoco. Sequenze e mappature formano collettivamente una raccolta.

Si noti che, come rappresentato nel diagramma mostrato sopra, gli scalari, le sequenze e le mappature sono rappresentati in un formato sistematico.

Vari tipi di caratteri vengono utilizzati per varie funzionalità. Questo capitolo parla in dettaglio della sintassi utilizzata in YAML e si concentra sulla manipolazione dei caratteri.

Caratteri indicatori

I caratteri indicatori includono una semantica speciale usata per descrivere il contenuto del documento YAML. La tabella seguente lo mostra in dettaglio.

Sr.No. Carattere e funzionalità
1

_

Denota una voce di sequenza di blocco
2

?

Denota una chiave di mappatura
3

:

Denota un valore di mappatura
4

,

Indica la voce di raccolta del flusso
5

[

Inizia una sequenza di flusso
6

]

Termina una sequenza di flusso
7

{

Avvia una mappatura del flusso
8

}

Termina una mappatura del flusso
9

#

Denota i commenti
10

&

Denota la proprietà di ancoraggio del nodo
11

*

Denota nodo alias
12

!

Denota il tag del nodo
13

|

Denota un blocco scalare letterale
14

>

Denota un blocco scalare piegato
15

`

Le virgolette singole circondano uno scalare di flusso quotato
16

"

Le virgolette doppie circondano il flusso scalare tra virgolette doppie
17

%

Denota la direttiva utilizzata

L'esempio seguente mostra i caratteri utilizzati nella sintassi:

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

In questo capitolo imparerai i seguenti aspetti delle primitive di sintassi in YAML:

  • Parametri di produzione
  • Spazi di rientro
  • Spazi di separazione
  • Prefisso di linea ignorato
  • Linea pieghevole

Cerchiamo di capire ogni aspetto in dettaglio.

Parametri di produzione

I parametri di produzione includono una serie di parametri e la gamma di valori consentiti utilizzati su una produzione specifica. Il seguente elenco di parametri di produzione viene utilizzato in YAML:

Rientro

È indicato dal carattere n o mIl flusso di caratteri dipende dal livello di rientro dei blocchi inclusi in esso. Molte produzioni hanno parametrizzato queste caratteristiche.

Contesto

È indicato da c. YAML supporta due gruppi di contesti:block styles e flow styles.

Stile

È indicato con s. Il contenuto scalare può essere presentato in uno dei cinque stili:plain, double quoted and single quoted flow, literal and folded block.

Masticare

È indicato da t. Gli scalari del blocco offrono molti meccanismi che aiutano a tagliare il blocco:strip, clip e keep. Il masticare aiuta a formattare le nuove stringhe di riga. Viene utilizzata la rappresentazione in stile blocco. Il processo di masticare avviene con l'aiuto di indicatori. Gli indicatori controllano quale output dovrebbe essere prodotto con le nuove righe di stringa. Le nuove righe vengono rimosse con(-) operatore e newline vengono aggiunti con (+) operatore.

Di seguito è mostrato un esempio per il processo di chomping:

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

L'output dopo l'analisi dell'esempio YAML specificato è il seguente:

Spazi di rientro

Nel flusso di caratteri YAML, il rientro è definito come un carattere di interruzione di riga di zero o più caratteri. Il punto più importante da tenere a mente è che il rientro non deve contenere caratteri di tabulazione. I caratteri nel rientro non dovrebbero mai essere considerati come parte delle informazioni sul contenuto del nodo. Osservare il codice seguente per una migliore comprensione:

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

L'output che puoi vedere dopo il rientro è il seguente:

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

Spazi di separazione

YAML utilizza caratteri spazio per la separazione tra i token. La nota più importante è che la separazione in YAML non deve contenere caratteri di tabulazione.

Il seguente solitario di codice mostra l'utilizzo degli spazi di separazione:

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

Prefisso di linea ignorato

Il prefisso vuoto include sempre un rientro a seconda del tipo scalare che include anche uno spazio bianco iniziale. Gli scalari semplici non devono contenere caratteri di tabulazione. D'altra parte, gli scalari tra virgolette possono contenere caratteri di tabulazione. Gli scalari del blocco dipendono completamente dall'indentazione.

L'esempio seguente mostra il funzionamento del prefisso di riga ignorato in modo sistematico:

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

L'output ottenuto per i flussi di blocchi è il seguente:

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

Linea pieghevole

Line Folding consente di rompere le linee lunghe per la leggibilità. Più quantità di righe brevi significano una migliore leggibilità. La piegatura della linea si ottiene annotando la semantica originale della linea lunga. L'esempio seguente mostra la piegatura della linea:

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

Puoi vedere l'output per la piegatura della linea in formato JSON come segue:

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

In YAML, ti imbatti in vari flussi di personaggi come segue:

  • Directives
  • Marcatori di confine del documento
  • Documents
  • Stream completo

In questo capitolo, li discuteremo in dettaglio.

Direttive

Le direttive sono istruzioni di base utilizzate nel processore YAML. Le direttive sono i dettagli della presentazione come i commenti che non si riflettono nell'albero di serializzazione. In YAML, non c'è modo di definire direttive private. Questa sezione discute vari tipi di direttive con esempi pertinenti:

Direttive riservate

Le direttive riservate vengono inizializzate con tre trattini (---) come mostrato nell'esempio seguente. Le direttive riservate vengono convertite in un valore specifico di JSON.

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

Direttiva YAML

Le direttive YAML sono direttive predefinite. Se convertito in JSON, il valore recuperato include il carattere barra nei caratteri precedenti e finali.

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

Marcatori di confine del documento

YAML utilizza questi marcatori per consentire a più di un documento di essere contenuto in un flusso. Questi marcatori sono usati specialmente per trasmettere la struttura del documento YAML. Notare che una riga che inizia con "---" viene utilizzata per iniziare un nuovo documento.

Il codice seguente spiega questo con esempi:

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

Documenti

Il documento YAML è considerato come una singola struttura dati nativa presentata come un singolo nodo radice. I dettagli di presentazione nel documento YAML come direttive, commenti, rientri e stili non sono considerati come contenuti inclusi in essi.

Esistono due tipi di documenti utilizzati in YAML. Sono spiegati in questa sezione:

Documenti espliciti

Inizia con l'indicatore di inizio del documento seguito dalla presentazione del nodo radice. Di seguito viene fornito l'esempio di dichiarazione esplicita YAML:

---

some: yaml

...

Include un marcatore di inizio e fine esplicito che è "---" e "..." nell'esempio dato. Convertendo lo YAML specificato in formato JSON, otteniamo l'output come mostrato di seguito -

{
   "some": "yaml"
}

Documenti impliciti

Questi documenti non iniziano con un indicatore di inizio documento. Rispettare il codice riportato di seguito -

fruits:
   - Apple
   - Orange
   - Pineapple
   - Mango

Convertendo questi valori in formato JSON otteniamo l'output come un semplice oggetto JSON come indicato di seguito -

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

Stream completo

YAML include una sequenza di byte chiamata come flusso di caratteri. Il flusso inizia con un prefisso contenente un ordine dei byte che denota una codifica dei caratteri. Lo stream completo inizia con un prefisso contenente una codifica dei caratteri, seguito da commenti.

Di seguito è mostrato un esempio di flusso completo (flusso di caratteri):

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

Ogni nodo di presentazione include due caratteristiche principali chiamate anchor e tag. Le proprietà del nodo possono essere specificate con il contenuto del nodo, omesso dal flusso di caratteri.

L'esempio di base della rappresentazione del nodo è il seguente:

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

Ancoraggi dei nodi

La proprietà anchor rappresenta un nodo per riferimento futuro. Il flusso di caratteri della rappresentazione YAML nel nodo è indicato conampersand (&)indicatore. Il processore YAML non ha bisogno di preservare il nome dell'ancora con i dettagli di rappresentazione composti in esso. Il codice seguente spiega questo:

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

L'output di YAML generato con i nodi di ancoraggio è mostrato di seguito:

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

Tag nodo

La proprietà tag rappresenta il tipo di struttura dati nativa che definisce completamente un nodo. Un tag è rappresentato con il (!) indicatore. I tag sono considerati parte integrante del grafico di rappresentazione. Il seguente esempio spiega in dettaglio i tag del nodo:

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

Contenuto del nodo

Il contenuto del nodo può essere rappresentato in un contenuto di flusso o in un formato a blocchi. Il contenuto del blocco si estende fino alla fine della riga e utilizza il rientro per denotare la struttura. Ogni tipo di raccolta può essere rappresentato in uno specifico stile di raccolta a flusso singolo o può essere considerato come un blocco unico. Il codice seguente lo spiega in dettaglio:

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

In questo capitolo, ci concentreremo sui vari tipi di scalari utilizzati per rappresentare il contenuto. In YAML, i commenti possono precedere o seguire il contenuto scalare. È importante notare che i commenti non devono essere inclusi nel contenuto scalare.

Si noti che tutti gli stili scalari di flusso possono includere più linee, tranne che con l'utilizzo in più chiavi.

La rappresentazione degli scalari è data di seguito:

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

L'output generato delle intestazioni scalari del blocco è mostrato di seguito:

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

Contenuto scalare di Document Marker

Tutti i caratteri in questo esempio sono considerati come contenuto, inclusi i caratteri dello spazio interno.

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

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

Le interruzioni di riga semplici sono rappresentate con l'esempio fornito di seguito:

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

L'output JSON corrispondente per lo stesso è menzionato di seguito:

"as space trimmed\nspecific\u2028\nnone"

Gli stili di flusso in YAML possono essere pensati come un'estensione naturale di JSON per coprire le linee di contenuto pieghevole per una funzionalità meglio leggibile che utilizza ancore e alias per creare le istanze dell'oggetto. In questo capitolo, ci concentreremo sulla rappresentazione del flusso dei seguenti concetti:

  • Nodi alias
  • Nodi vuoti
  • Stili scalari di flusso
  • Stili di raccolta Flow
  • Nodi di flusso

L'esempio di nodi alias è mostrato di seguito:

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

L'output JSON del codice sopra riportato è riportato di seguito:

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

I nodi con contenuto vuoto sono considerati nodi vuoti. L'esempio seguente mostra questo:

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

L'output dei nodi vuoti in JSON è rappresentato come di seguito:

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

Gli stili scalari di flusso includono i tipi con virgolette doppie, virgolette singole e semplici. L'esempio di base per lo stesso è fornito di seguito:

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

L'output in formato JSON per l'esempio sopra riportato è mostrato di seguito:

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

La raccolta di flussi in YAML è nidificata con una raccolta di blocchi all'interno di un'altra raccolta di flussi. Le voci di raccolta del flusso vengono terminate concomma (,) indicatore. L'esempio seguente spiega in dettaglio il blocco di raccolta del flusso:

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

L'output per la raccolta di flussi in JSON è mostrato di seguito:

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

Gli stili di flusso come JSON includono indicatori di inizio e fine. L'unico stile di flusso che non ha alcuna proprietà è il semplice scalare.

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

L'output per il codice mostrato sopra in formato JSON è fornito di seguito:

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

YAML include due stili scalari di blocco: literal e folded. Gli scalari di blocco sono controllati con pochi indicatori con un'intestazione che precede il contenuto stesso. Di seguito viene fornito un esempio di intestazioni scalari di blocco:

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

Di seguito è riportato l'output in formato JSON con un comportamento predefinito:

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

Tipi di stili di blocco

Esistono quattro tipi di stili di blocco: literal, folded, keep e stripstili. Questi stili di blocco sono definiti con l'aiuto dello scenario Block Chomping. Di seguito viene fornito un esempio di scenario di chomping a blocchi:

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

Puoi vedere l'output generato con tre formati in JSON come indicato di seguito:

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

Chomping in YAML controlla le interruzioni finali e le righe vuote finali che vengono interpretate in varie forme.

Stripping

In questo caso, l'interruzione di riga finale e le righe vuote sono escluse per il contenuto scalare. È specificato dall'indicatore di chomping “-“.

Ritaglio

Il ritaglio è considerato un comportamento predefinito se non viene specificato alcun indicatore di morso esplicito. Il carattere di interruzione finale viene conservato nel contenuto dello scalare. Il miglior esempio di ritaglio è dimostrato nell'esempio sopra. Termina con una nuova riga“\n” personaggio.

Mantenere

Keeping si riferisce all'aggiunta con la rappresentazione dell'indicatore di chomping "+". Le linee aggiuntive create non sono soggette a piegatura. Le linee aggiuntive non sono soggette a piegatura.

Per comprendere gli stili di sequenza, è importante comprendere le raccolte. Il concetto di raccolte e stili di sequenza funzionano in parallelo. La raccolta in YAML è rappresentata con gli stili di sequenza appropriati. Se vuoi fare riferimento alla corretta sequenza dei tag, fai sempre riferimento alle raccolte. Le raccolte in YAML sono indicizzate da numeri interi sequenziali che iniziano con zero come rappresentato negli array. Il fulcro degli stili di sequenza inizia con le raccolte.

Esempio

Consideriamo il numero di pianeti nell'universo come una sequenza che può essere creata come una raccolta. Il codice seguente mostra come rappresentare gli stili di sequenza dei pianeti nell'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

Quindi, puoi vedere il seguente output per la sequenza ordinata in formato JSON:

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

Le mappature di flusso in YAML rappresentano la raccolta non ordinata di coppie di valori chiave. Sono anche chiamati nodi di mappatura. Notare che le chiavi dovrebbero essere mantenute uniche. Se c'è una duplicazione di chiavi nella struttura di mappatura del flusso, verrà generato un errore. L'ordine delle chiavi viene generato nell'albero di serializzazione.

Esempio

Di seguito è riportato un esempio di struttura di mappatura del flusso:

%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

L'output della sequenza mappata (elenco non ordinato) in formato JSON è come mostrato di seguito -

{
   "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 si osserva questo output come mostrato sopra, si osserva che i nomi delle chiavi vengono mantenuti univoci nella struttura di mappatura YAML.

Le sequenze di blocchi di YAML rappresentano una serie di nodi. Ogni elemento è contrassegnato da un indicatore iniziale "-". Nota che l'indicatore "-" in YAML dovrebbe essere separato dal nodo con uno spazio bianco.

La rappresentazione di base della sequenza di blocchi è fornita di seguito:

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

Esempio

Osservare i seguenti esempi per una migliore comprensione delle sequenze di blocchi.

Esempio 1

port: &ports
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *ports

L'output delle sequenze di blocchi in formato JSON è fornito di seguito:

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

Uno schema YAML è definito come una combinazione di un insieme di tag e include un meccanismo per la risoluzione di tag non specifici. Lo schema fail-safe in YAML è creato in modo tale da poter essere utilizzato con qualsiasi documento YAML. È anche considerato come uno schema consigliato per un documento YAML generico.

Tipi

Esistono due tipi di schemi di sicurezza: Generic Mapping e Generic Sequence

Mappatura generica

Rappresenta un contenitore associativo. Qui, ogni chiave è univoca nell'associazione e mappata esattamente a un valore. YAML non include restrizioni per le definizioni chiave.

Di seguito viene fornito un esempio per rappresentare la mappatura generica:

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

L'output della struttura di mappatura generica in formato JSON è mostrato di seguito:

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

Sequenza generica

Rappresenta un tipo di sequenza. Include una raccolta indicizzata da numeri interi sequenziali che iniziano con zero. È rappresentato con!!seq etichetta.

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

L'output per questa sequenza generica di failsafe

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

Lo schema JSON in YAML è considerato il denominatore comune della maggior parte dei linguaggi informatici moderni. Consente l'analisi dei file JSON. Si raccomanda vivamente in YAML di considerare altri schemi sullo schema JSON. La ragione principale di ciò è che include combinazioni di valori chiave che sono facili da usare. I messaggi possono essere codificati come chiave e possono essere utilizzati come e quando necessario.

Lo schema JSON è scalare e manca di un valore. Una voce di mappatura nello schema JSON è rappresentata nel formato di una coppia chiave e valore in cui null viene considerato valido.

Esempio

Uno schema JSON nullo è rappresentato come mostrato di seguito -

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

L'output della rappresentazione JSON è menzionato di seguito:

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

Esempio

L'esempio seguente rappresenta lo schema JSON booleano:

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

Di seguito è riportato l'output per lo stesso in formato JSON:

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

Esempio

L'esempio seguente rappresenta lo schema JSON intero:

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

Esempio

I tag nello schema JSON sono rappresentati con il seguente esempio:

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 ]

Puoi trovare l'output JSON come mostrato di seguito -

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