YAML - YAML

YAML
Extensions de nom de fichier	.yaml, .yml
Type de média Internet	Non enregistré
Première version	11 mai 2001 ; il y a 20 ans
Dernière version	1.2 (troisième édition) ; (1er octobre 2009 ; il y a 12 ans )
Type de format	Échange de données
Format ouvert ?	Oui
Site Internet	YAML .org

YAML ( voir § Historique et nom ) est un langage de sérialisation de données lisible par l'homme . Il est couramment utilisé pour les fichiers de configuration et dans les applications où des données sont stockées ou transmises. YAML cible bon nombre des mêmes applications de communication que le langage de balisage extensible (XML) mais a une syntaxe minimale qui diffère intentionnellement de SGML . Il utilise à la fois une indentation de style Python pour indiquer l'imbrication et un format plus compact utilisé pour les listes et les cartes. Les fichiers JSON sont donc YAML 1.2 valides. [...]{...}

Les types de données personnalisés sont autorisés, mais YAML encode nativement les scalaires (tels que les chaînes , les entiers et les flottants ), les listes et les tableaux associatifs (également appelés cartes, dictionnaires ou hachages). Ces types de données sont basés sur le langage de programmation Perl , bien que tous les langages de programmation de haut niveau couramment utilisés partagent des concepts très similaires. La syntaxe centrée sur les deux-points, utilisée pour exprimer les paires clé-valeur , est inspirée des en - têtes de courrier électronique tels que définis dans la RFC 822 , et le séparateur de document --- est emprunté à MIME ( RFC 2046 ). Les séquences d'échappement sont réutilisées à partir de C , et l'habillage d'espaces pour les chaînes multilignes est inspiré du HTML . Les listes et les hachages peuvent contenir des listes et des hachages imbriqués, formant une structure arborescente ; des graphes arbitraires peuvent être représentés à l'aide d'alias YAML (similaire à XML dans SOAP ). YAML est destiné à être lu et écrit en flux, une fonctionnalité inspirée de SAX .

La prise en charge de la lecture et de l'écriture de YAML est disponible pour de nombreux langages de programmation. Certains éditeurs de code source tels qu'Emacs et divers environnements de développement intégrés ont des fonctionnalités qui facilitent l'édition de YAML, telles que le repliement des structures imbriquées ou la mise en évidence automatique des erreurs de syntaxe.

L' extension de nom de fichier officielle recommandée pour les fichiers YAML est .yamldepuis 2006.

Histoire et nom

YAML ( / j æ m əl / , rime avec chameau ) a été d' abord proposé par Clark Evans en 2001, qui l'a conçu avec Ingy Net et Oren DÖT Ben-Kiki. À l'origine, YAML était censé signifier un autre langage de balisage , car il a été publié à une époque qui a vu une prolifération de langages de balisage pour la présentation et la connectivité (HTML, XML, SGML, etc.). Son nom initial était conçu comme une référence ironique au paysage technologique, faisant référence à son objectif en tant que langage de balisage avec une autre construction, mais il a ensuite été réutilisé sous le nom de YAML Ain't Markup Language , un acronyme récursif , pour distinguer son objectif en tant que balisage axé sur les données plutôt que sur le document.

Concevoir

Syntaxe

Une aide-mémoire et les spécifications complètes sont disponibles sur le site officiel. Ce qui suit est un résumé des éléments de base.

YAML accepte l'intégralité du jeu de caractères Unicode, à l'exception de certains caractères de contrôle , et peut être codé dans l'un des UTF-8 , UTF-16 ou UTF-32 . (Bien que UTF-32 ne soit pas obligatoire, il est nécessaire qu'un analyseur soit compatible JSON .)

L' indentation des espaces est utilisée pour désigner la structure ; cependant, les caractères de tabulation ne sont pas autorisés dans le cadre de cette indentation.
Les commentaires commencent par le signe dièse ( #), peuvent commencer n'importe où sur une ligne et se poursuivre jusqu'à la fin de la ligne. Les commentaires doivent être séparés des autres jetons par des espaces. Si # caractères apparaissent à l'intérieur d'une chaîne, il s'agit de #littéraux de signe dièse ( ).
Les membres de la liste sont indiqués par un trait d'union ( -) avec un membre par ligne.
- Une liste peut également être spécifiée en mettant le texte entre crochets ( [...]) avec chaque entrée séparée par une virgule .
Une entrée de tableau associatif est représentée à l'aide d' un espace
deux-points
sous la forme clé : valeur avec une entrée par ligne. YAML exige que les deux points soient suivis d'un espace afin que les valeurs scalaires telles que http://www.wikipedia.orgpuissent généralement être représentées sans avoir besoin d'être entourées de guillemets.
- Un point d' interrogation peut être utilisé devant une clé, sous la forme "?key: value" pour permettre à la clé de contenir des tirets, des crochets, etc., sans guillemets.
- Un tableau associatif peut également être spécifié par du texte entouré d' accolades ( {...}), avec des clés séparées des valeurs par des deux-points et les entrées séparées par des virgules (les espaces ne sont pas nécessaires pour conserver la compatibilité avec JSON).
Les chaînes (un type de scalaire en YAML) sont généralement sans guillemets, mais peuvent être entourées de guillemets doubles ( ") ou de guillemets simples ( ').
- Entre guillemets doubles, les caractères spéciaux peuvent être représentés par des séquences d'échappement de style C commençant par une barre oblique inverse ( \). Selon la documentation, le seul échappement octal pris en charge est \0.
- Dans les guillemets simples, la seule séquence d'échappement prise en charge est un guillemet simple doublé ( '') désignant le guillemet simple lui-même comme dans 'don''t'.
Les blocs scalaires sont délimités par une indentation avec des modificateurs facultatifs pour préserver ( |) ou replier ( >) les retours à la ligne.
Plusieurs documents au sein d'un même flux sont séparés par trois tirets ( ---).
- Trois points ( ...) terminent éventuellement un document dans un flux.
Les nœuds répétés sont initialement désignés par une esperluette ( &) et ensuite référencés par un astérisque ( *).
Les nœuds peuvent être étiquetés avec un type ou une balise utilisant un double point d'exclamation ( !!) suivi d'une chaîne, qui peut être développée en un URI.
Les documents YAML dans un flux peuvent être précédés de « directives » composées d'un signe de pourcentage ( %) suivi d'un nom et de paramètres délimités par des espaces. Deux directives sont définies dans YAML 1.1 :
- La directive %YAML est utilisée pour identifier la version de YAML dans un document donné.
- La directive %TAG est utilisée comme raccourci pour les préfixes d'URI. Ces raccourcis peuvent ensuite être utilisés dans les balises de type nœud.

Deux caractères de sigil supplémentaires sont réservés dans YAML pour une éventuelle spécification future : le signe at ( @) et le backtick ( `).

Composants de base

YAML propose un style "en ligne" pour désigner les tableaux et les listes associatifs. Voici un échantillon des composants.

Le format de bloc conventionnel utilise un trait d'union + espace pour commencer un nouvel élément dans la liste.

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

Le format en ligne facultatif est délimité par une virgule + un espace et entre crochets (similaire à JSON ).

--- # Shopping list
[milk, pumpkin pie, eggs, juice]

Les clés sont séparées des valeurs par deux points + espace. Les blocs indentés, courants dans les fichiers de données YAML, utilisent l'indentation et les nouvelles lignes pour séparer les paires clé/valeur. Les blocs en ligne, courants dans les flux de données YAML, utilisent une virgule + un espace pour séparer les paires clé/valeur entre les accolades.

--- # Indented Block
  name: John Smith
  age: 33
--- # Inline Block
{name: John Smith, age: 33}

Les chaînes ne nécessitent pas de guillemets. Il existe deux façons d'écrire des chaînes multilignes, l'une en préservant les retours à la ligne (en utilisant le |caractère) et l'autre en pliant les retours à la ligne (en utilisant le >caractère), toutes deux suivies d'un caractère de retour à la ligne.

data: |
   There once was a tall man from Ealing
   Who got on a bus to Darjeeling
       It said on the door
       "Please don't sit on the floor"
   So he carefully sat on the ceiling

Par défaut, l'indentation de début (de la première ligne) et les espaces de fin sont supprimés, bien que d'autres comportements puissent être explicitement spécifiés.

data: >
   Wrapped text
   will be folded
   into a single
   paragraph

   Blank lines denote
   paragraph breaks

Le texte plié convertit les nouvelles lignes en espaces et supprime les espaces de début.

--- # The Smiths
- {name: John Smith, age: 33}
- name: Mary Smith
  age: 27
- [name, age]: [Rae Smith, 4]   # sequences as keys are supported
--- # People, by gender
men: [John Smith, Bill Jones]
women:
  - Mary Smith
  - Susan Williams

Les objets et les listes sont des composants importants de yaml et peuvent être mélangés. Le premier exemple est une liste d'objets clé-valeur, tous des membres de la famille Smith. La seconde les répertorie par genre ; c'est un objet clé-valeur contenant deux listes.

Composants avancés

Deux caractéristiques qui distinguent YAML des capacités des autres langages de sérialisation de données sont les structures et le typage des données.

Les structures YAML permettent le stockage de plusieurs documents dans un seul fichier, l'utilisation de références pour des nœuds répétés et l'utilisation de nœuds arbitraires comme clés.

Pour plus de clarté, de compacité et pour éviter les erreurs de saisie de données, YAML fournit des ancres de nœud (à l'aide de &) et des références (à l'aide de *). Les références à l'ancre fonctionnent pour tous les types de données (voir la référence de livraison dans l'exemple ci-dessous).

Vous trouverez ci-dessous un exemple de file d'attente dans un séquenceur d'instruments dans lequel deux étapes sont réutilisées à plusieurs reprises sans être entièrement décrites à chaque fois.

--- # Sequencer protocols for Laser eye surgery
- step:  &id001                  # defines anchor label &id001
    instrument:      Lasik 2000
    pulseEnergy:     5.4
    pulseDuration:   12
    repetition:      1000
    spotSize:        1mm

- step: &id002
    instrument:      Lasik 2000
    pulseEnergy:     5.0
    pulseDuration:   10
    repetition:      500
    spotSize:        2mm
- step: *id001                   # refers to the first step (with anchor &id001)
- step: *id002                   # refers to the second step
- step: *id002

Le typage explicite des données est rarement observé dans la majorité des documents YAML, car YAML détecte automatiquement les types simples. Les types de données peuvent être divisés en trois catégories : principales, définies et définies par l'utilisateur. Les noyaux sont ceux qui devraient exister dans n'importe quel analyseur (par exemple, les flottants, les entiers, les chaînes, les listes, les cartes, ...). De nombreux types de données plus avancés, tels que les données binaires, sont définis dans la spécification YAML mais ne sont pas pris en charge dans toutes les implémentations. Enfin, YAML définit un moyen d'étendre les définitions de types de données localement pour s'adapter aux classes, structures ou primitives définies par l'utilisateur (par exemple, les flottants quad-précision).

YAML détecte automatiquement le type de données de l'entité, mais parfois on veut transtyper explicitement le type de données. La situation la plus courante est celle où une chaîne d'un seul mot qui ressemble à un nombre, un booléen ou une balise nécessite une ambiguïté en l'entourant de guillemets ou en utilisant une balise de type de données explicite.

---
a: 123                     # an integer
b: "123"                   # a string, disambiguated by quotes
c: 123.0                   # a float
d: !!float 123             # also a float via explicit data type prefixed by (!!)
e: !!str 123               # a string, disambiguated by explicit type
f: !!str Yes               # a string via explicit type
g: Yes                     # a boolean True (yaml1.1), string "Yes" (yaml1.2)
h: Yes we have No bananas  # a string, "Yes" and "No" disambiguated by context.

Toutes les implémentations de YAML n'ont pas tous les types de données définis par les spécifications. Ces types intégrés utilisent un préfixe de sigil à double point d'exclamation ( !!). Les ensembles, les cartes ordonnées, les horodatages et l'hexadécimal ne sont pas particulièrement intéressants. Voici un exemple de données binaires codées en base64 .

---
picture: !!binary |
  R0lGODdhDQAIAIAAAAAAANn
  Z2SwAAAAADQAIAAACF4SDGQ
  ar3xxbJ9p0qa7R0YxwzaFME
  1IAADs=

De nombreuses implémentations de YAML peuvent prendre en charge les types de données définis par l'utilisateur pour la sérialisation d'objets. Les types de données locaux ne sont pas des types de données universels, mais sont définis dans l'application à l'aide de la bibliothèque d'analyseur YAML. Les types de données locaux utilisent un seul point d'exclamation ( !).

---
myObject: !myClass { name: Joe, age: 15 }

Exemple

La hiérarchie de la structure des données est maintenue par l'indentation des contours.

---
receipt:     Oz-Ware Purchase Invoice
date:        2012-08-06
customer:
    first_name:   Dorothy
    family_name:  Gale

items:
    - part_no:   A4786
      descrip:   Water Bucket (Filled)
      price:     1.47
      quantity:  4

    - part_no:   E1628
      descrip:   High Heeled "Ruby" Slippers
      size:      8
      price:     133.7
      quantity:  1

bill-to:  &id001
    street: |
            123 Tornado Alley
            Suite 16
    city:   East Centerville
    state:  KS

ship-to:  *id001

specialDelivery:  >
    Follow the Yellow Brick
    Road to the Emerald City.
    Pay no attention to the
    man behind the curtain.
...

Notez que les chaînes ne nécessitent pas de mise entre guillemets. Le nombre spécifique d'espaces dans l'indentation n'a pas d'importance tant que les éléments parallèles ont la même justification à gauche et que les éléments imbriqués hiérarchiquement sont davantage indentés. Cet exemple de document définit un tableau associatif avec 7 clés de niveau supérieur : l'une des clés, "items", contient une liste à 2 éléments, dont chaque élément est lui-même un tableau associatif avec des clés différentes. Les données relationnelles et la suppression des redondances sont affichées : le contenu du tableau associatif "livraison" est copié à partir du contenu du tableau associatif "facturation" comme indiqué par les libellés d' ancrage ( &) et de référence ( *). Des lignes vierges facultatives peuvent être ajoutées pour plus de lisibilité. Plusieurs documents peuvent exister dans un seul fichier/flux et sont séparés par ---. Un facultatif ...peut être utilisé à la fin d'un fichier (utile pour signaler la fin des communications en streaming sans fermer le tube).

Caractéristiques

Délimitation en retrait

Parce que YAML repose principalement sur l'indentation des contours pour la structure, il est particulièrement résistant à la collision de délimiteurs . L'insensibilité de YAML aux guillemets et aux accolades dans les valeurs scalaires signifie que l'on peut intégrer des documents XML, JSON ou même YAML dans un document YAML en l'indentant simplement dans un bloc littéral (en utilisant |ou >):

---
example: >
        HTML goes into YAML without modification
message: |

        <blockquote style="font: italic 1em serif">
        <p>"Three is always greater than two,
           even for large values of two"</p>
        <p>--Author Unknown</p>
        </blockquote>
date: 2007-06-01

YAML peut être placé dans JSON en citant et en échappant tous les guillemets intérieurs. YAML peut être placé dans XML en échappant les caractères réservés ( <, >, &, ', ") et en convertissant les espaces blancs, ou en le plaçant dans une section CDATA .

Modèles de données non hiérarchiques

Contrairement à JSON, qui ne peut représenter des données que dans un modèle hiérarchique avec chaque nœud enfant ayant un seul parent, YAML propose également un schéma relationnel simple qui permet de référencer des répétitions de données identiques à partir de deux ou plusieurs points de l'arbre plutôt que de les saisir de manière redondante à ces points. Ceci est similaire à la fonction IDREF intégrée à XML. L'analyseur YAML étend ensuite ces références dans les structures de données entièrement remplies qu'elles impliquent lorsqu'elles sont lues, de sorte que quel que soit le programme qui utilise l'analyseur, il n'est pas nécessaire de connaître un modèle de codage relationnel, contrairement aux processeurs XML, qui n'étendent pas les références. Cette extension peut améliorer la lisibilité tout en réduisant les erreurs de saisie de données dans les fichiers de configuration ou les protocoles de traitement où de nombreux paramètres restent les mêmes dans une série séquentielle d'enregistrements alors que seuls quelques-uns varient. Un exemple étant que les enregistrements "ship-to" et "bill-to" dans une facture sont presque toujours les mêmes données.

Considérations pratiques

YAML est orienté ligne et il est donc souvent simple de convertir la sortie non structurée de programmes existants au format YAML tout en leur permettant de conserver une grande partie de l'apparence du document d'origine. Comme il n'y a pas de balises fermantes, d'accolades ou de guillemets à équilibrer, il est généralement facile de générer un YAML bien formé directement à partir d'instructions d'impression distribuées dans des programmes peu sophistiqués. De même, les délimiteurs d'espaces facilitent le filtrage rapide et sale des fichiers YAML à l'aide des commandes orientées ligne dans grep, AWK, Perl, Ruby et Python.

En particulier, contrairement aux langages de balisage, des morceaux de lignes YAML consécutives ont tendance à être eux-mêmes des documents YAML bien formés. Cela rend très facile l'écriture d'analyseurs qui n'ont pas à traiter un document dans son intégralité (par exemple, équilibrer les balises d'ouverture et de fermeture et naviguer entre les guillemets et les caractères d'échappement) avant de commencer à extraire des enregistrements spécifiques à l'intérieur. Cette propriété est particulièrement utile lors de l'itération en une seule passe sans état, sur des enregistrements dans un fichier dont la structure de données entière est trop volumineuse pour être conservée en mémoire, ou pour lesquels la reconstitution de la structure entière pour extraire un élément serait d'un coût prohibitif.

Contre-intuitivement, bien que sa délimitation par indentation puisse sembler compliquer les hiérarchies profondément imbriquées, YAML gère des indentations aussi petites qu'un seul espace, ce qui peut permettre une meilleure compression que les langages de balisage. De plus, une indentation extrêmement profonde peut être entièrement évitée en : 1) revenant au « style en ligne » (c'est-à-dire au format de type JSON) sans l'indentation ; ou 2) en utilisant des ancres relationnelles pour dérouler la hiérarchie sous une forme plate que l'analyseur YAML reconstituera de manière transparente dans la structure de données complète.

Sécurité

YAML est purement un langage de représentation de données et n'a donc pas de commandes exécutables. Alors que la validation et l'analyse sécurisée sont intrinsèquement possibles dans n'importe quel langage de données, la mise en œuvre est un piège si notoire que l'absence de langage de commande associé à YAML peut être un avantage relatif en matière de sécurité.

Cependant, YAML autorise les balises spécifiques à la langue afin que des objets locaux arbitraires puissent être créés par un analyseur qui prend en charge ces balises. Tout analyseur YAML qui permet l'exécution d'une instanciation d'objet sophistiqué ouvre le potentiel d'une attaque par injection. Les parseurs Perl qui permettent le chargement d'objets de classes arbitraires créent des valeurs dites « bénies ». L'utilisation de ces valeurs peut déclencher un comportement inattendu, par exemple si la classe utilise des opérateurs surchargés. Cela peut conduire à l'exécution de code Perl arbitraire.

La situation est similaire pour les parseurs Python ou Ruby. D'après la documentation PyYAML :

Notez que la possibilité de construire un objet Python arbitraire peut être dangereuse si vous recevez un document YAML d'une source non fiable telle qu'Internet. La fonction yaml.safe_loadlimite cette capacité aux objets Python simples comme les entiers ou les listes. [...]

PyYAML vous permet de construire un objet Python de n'importe quel type. Même des instances de classes Python peuvent être construites à l'aide de la !!python/objectbalise.

Traitement et représentation des données

La spécification YAML identifie une instance de document en tant que "Présentation" ou "Flux de caractères". Les principales structures logiques dans un document d'instance YAML sont les scalaires, les séquences et les mappages. La spécification YAML indique également certaines contraintes de base qui s'appliquent à ces structures logiques primaires. Par exemple, selon la spécification, les clés de mappage n'ont pas d'ordre. Dans tous les cas où l'ordre des nœuds est significatif, une séquence doit être utilisée.

De plus, en définissant la conformité des processeurs YAML, la spécification YAML définit deux opérations principales : dump et load . Tous les processeurs compatibles YAML doivent fournir au moins une de ces opérations, et peuvent éventuellement fournir les deux. Enfin, la spécification YAML définit un modèle d'information ou "graphe de représentation", qui doit être créé lors du traitement pour les opérations de vidage et de chargement , bien que cette représentation n'ait pas besoin d'être mise à disposition de l'utilisateur via une API.

Comparaison avec d'autres formats de sérialisation

Comparaison avec JSON

La syntaxe JSON est une base de YAML version 1.2, qui a été promulguée dans le but exprès de mettre YAML « en conformité avec JSON en tant que sous-ensemble officiel ». Bien que les versions antérieures de YAML n'étaient pas strictement compatibles, les écarts étaient rarement perceptibles et la plupart des documents JSON peuvent être analysés par certains analyseurs YAML tels que Syck. En effet, la structure sémantique de JSON est équivalente au "style en ligne" facultatif de l'écriture de YAML. Bien que les hiérarchies étendues puissent être écrites dans un style en ligne comme JSON, ce n'est pas un style YAML recommandé, sauf lorsqu'il contribue à la clarté.

YAML possède de nombreuses fonctionnalités supplémentaires manquantes dans JSON, notamment des commentaires, des types de données extensibles, des ancres relationnelles, des chaînes sans guillemets et des types de mappage préservant l'ordre des clés.

Comparaison avec TOML

D'une part, YAML est beaucoup plus complexe que TOML - la spécification YAML a été signalée comme ayant 23 449 mots, alors que la spécification TOML n'avait que 3 339 mots. En revanche, YAML est moins verbeux, plus DRY , syntaxiquement moins bruyant, et la hiérarchie d'un document ressort clairement de l'indentation.

Comparaison avec XML

YAML n'a pas la notion d'attributs de balise que l'on trouve dans XML. Au lieu de cela, YAML a des déclarations de type extensibles (y compris les types de classe pour les objets).

YAML lui-même n'a pas de descripteurs de schéma de document XML qui permettent, par exemple, à un document de s'auto-valider. Cependant, il existe plusieurs langages de description de schéma définis en externe pour YAML (par exemple Doctrine , Kwalify et Rx) qui remplissent ce rôle. De plus, la sémantique fournie par les déclarations de type défini par le langage de YAML dans le document YAML lui-même assouplit fréquemment le besoin d'un validateur dans des situations simples et courantes. De plus, YAXML , qui représente les structures de données YAML en XML, permet aux importateurs de schéma XML et aux mécanismes de sortie comme XSLT d'être appliqués à YAML.

La comparaison des formats de sérialisation des données fournit une comparaison plus complète de YAML avec d'autres formats de sérialisation.

Logiciels (émetteurs et analyseurs)

Pour les structures de données fixes, les fichiers YAML peuvent simplement être générés à l'aide de commandes d' impression qui écrivent à la fois les données et la décoration spécifique YAML. Cependant, pour vider des données hiérarchiques variables ou complexes, un émetteur YAML dédié est préférable. De même, les fichiers YAML simples (par exemple les paires clé-valeur) sont facilement analysés avec des expressions régulières. Pour les structures de données plus complexes ou variables, un analyseur YAML formel est recommandé.

Les émetteurs et analyseurs YAML existent pour de nombreux langages populaires. La plupart d'entre eux sont écrits dans la langue maternelle elle-même. Certaines sont des liaisons de langage de la bibliothèque C libyaml ; ils peuvent courir plus vite. Il y avait une autre bibliothèque C, appelée Syck , écrite et orpheline par pourquoi le chanceux raide : elle n'est pas maintenue, il n'y a pas de bundle de source faisant autorité, et le site Web a été piraté. Par conséquent, la seule bibliothèque C recommandée est libyaml . Il a été développé à l'origine par Kirill Simonov. En 2018, le développement a été repris par les nouveaux mainteneurs Ian Cordasco et Ingy döt Net .

Les programmeurs C++ ont le choix entre la bibliothèque C libyaml et la bibliothèque C++ libyaml-cpp . Les deux ont des bases de code complètement indépendantes et des API complètement différentes . La bibliothèque libyaml-cpp a toujours un numéro de version majeur de 0, indiquant que l'API peut changer à tout moment, comme cela s'est d'ailleurs produit après la version 0.3. Il existe une implémentation centrée sur la grammaire écrite en C#, dans le but d'étendre les éléments imbriqués.

Certaines implémentations de YAML, telles que YAML.pm de Perl, chargeront un fichier entier (flux) et l'analyseront en masse . D'autres implémentations telles que PyYaml sont paresseuses et itèrent sur le document suivant uniquement sur demande. Pour les fichiers très volumineux dans lesquels on envisage de traiter les documents de manière autonome, l'instanciation de l'intégralité du fichier avant traitement peut s'avérer rédhibitoire. Ainsi, dans YAML.pm, il faut parfois fragmenter un fichier en documents et les analyser individuellement. YAML rend cela facile, car cela nécessite simplement une division sur le marqueur de fin de document, qui est défini comme trois points sur une ligne par eux-mêmes. Ce marqueur est interdit dans le contenu.

Critique

YAML a été critiqué pour ses espaces blancs importants , ses fonctionnalités déroutantes, ses valeurs par défaut non sécurisées et sa spécification complexe et ambiguë :

Les fichiers de configuration peuvent exécuter des commandes ou charger du contenu sans que les utilisateurs s'en rendent compte.
La modification de gros fichiers YAML est difficile, car les erreurs d'indentation peuvent passer inaperçues.
L'autodétection de type est une source d'erreurs. Par exemple, sans guillemets Yeset NOsont convertis en booléens ; les numéros de version du logiciel peuvent être convertis en flottants.
Les fichiers tronqués sont souvent interprétés comme YAML valide en raison de l'absence de terminateurs.
La complexité de la norme a conduit à des implémentations incohérentes et à rendre le langage non portable.

Les défauts perçus et la complexité de YAML ont conduit à l'émergence d'alternatives plus strictes telles que StrictYAML et NestedText .

Voir également

Les références

Liens externes

Site officiel

Languages

In other projects