YAML - Processus

YAML suit une procédure standard pour le flux de processus. La structure de données native dans YAML comprend des représentations simples telles que des nœuds. Il est également appelé graphique de nœud de représentation.

Il comprend le mappage, la séquence et les quantités scalaires qui sont sérialisées pour créer une arborescence de sérialisation. Avec la sérialisation, les objets sont convertis avec un flux d'octets.

L'arborescence des événements de sérialisation permet de créer une présentation des flux de caractères comme représenté dans le diagramme suivant.

La procédure inverse analyse le flux d'octets en arborescence d'événements sérialisés. Plus tard, les nœuds sont convertis en graphe de nœuds. Ces valeurs sont ensuite converties dans la structure de données native YAML. La figure ci-dessous explique cela -

Les informations contenues dans YAML sont utilisées de deux manières: machine processing et human consumption. Le processeur en YAML est utilisé comme un outil pour la procédure de conversion d'informations entre des vues complémentaires dans le schéma ci-dessus. Ce chapitre décrit les structures d'informations qu'un processeur YAML doit fournir dans une application donnée.

YAML comprend une procédure de sérialisation pour représenter les objets de données au format série. Le traitement des informations YAML comprend trois étapes:Representation, Serialization, Presentation and parsing. Laissez-nous discuter de chacun d'eux en détail.

Représentation

YAML représente la structure de données à l'aide de trois types de nœuds: sequence, mapping et scalar.

Séquence

La séquence fait référence au nombre ordonné d'entrées, qui mappe l'association non ordonnée de la paire clé-valeur. Il correspond à la liste des tableaux Perl ou Python.

Le code ci-dessous est un exemple de représentation de séquence -

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

Cartographie

Le mappage, quant à lui, représente la structure de données du dictionnaire ou la table de hachage. Un exemple pour le même est mentionné ci-dessous -

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

Scalaires

Les scalaires représentent les valeurs standard des chaînes, des entiers, des dates et des types de données atomiques. Notez que YAML comprend également des nœuds qui spécifient la structure du type de données. Pour plus d'informations sur les scalaires, veuillez vous référer au chapitre 6 de ce tutoriel.

Sérialisation

Un processus de sérialisation est requis dans YAML, ce qui facilite l'ordre des clés et les noms d'ancrage conviviaux. Le résultat de la sérialisation est une arborescence de sérialisation YAML. Il peut être traversé pour produire une série d'appels d'événement de données YAML.

Un exemple de sérialisation est donné ci-dessous -

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

Présentation

La sortie finale de la sérialisation YAML est appelée présentation. Il représente un flux de personnages d'une manière humaine. Le processeur YAML comprend divers détails de présentation pour la création de flux, la gestion de l'indentation et le formatage du contenu. Ce processus complet est guidé par les préférences de l'utilisateur.

Un exemple de processus de présentation YAML est le résultat de la création de la valeur JSON. Observez le code ci-dessous pour une meilleure compréhension -

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

Analyse

L'analyse est le processus inverse de présentation; il comprend un flux de personnages et crée une série d'événements. Il ignore les détails introduits dans le processus de présentation qui provoque des événements de sérialisation. La procédure d'analyse peut échouer en raison d'une entrée mal formée. Il s'agit essentiellement d'une procédure pour vérifier si YAML est bien formé ou non.

Prenons un exemple YAML mentionné ci-dessous -

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

Avec trois traits d'union, il représente le début du document avec divers attributs définis ultérieurement.

YAML lint est l'analyseur en ligne de YAML et aide à analyser la structure YAML pour vérifier si elle est valide ou non. Le lien officiel pour les peluches YAML est mentionné ci-dessous:http://www.yamllint.com/

Vous pouvez voir la sortie de l'analyse comme indiqué ci-dessous -