# data[].attributes.body
Beschreibung:
- Ist ein textbasiertes Datenformat zur strukturieren von Daten
- Ist Systemunabhängig

Aufbau:
- Hat einen Baumstruktur
- Daten werden Tags/Elemente zugewiesen

Verwendung:
- Als HTML
- Austausch von Informationen

Quelle: https://hellocoding.de/blog/coding-language/html/xml
__________
Jasin Manachadshijev

# data[].attributes.body
Depending on whom you ask, YAML stands for yet another markup language or YAML ain't markup language (a recursive acronym), which emphasizes that YAML is for data, not documents.

# data[].attributes.body
Struktur von einem Objekt in JSON

# data[].attributes.body
[dʒeɪsən]

# data[].attributes.body
Nehmen wir an, Sie haben ein Python-Wörterbuch. Wie erstellen Sie daraus einen JSON-String?

Sie können dies mit der Option dumps() Methode mit dieser Syntax:

<json_str> = json.dumps(<dict_obj>)

Copy

Hier,

ist das Python-Wörterbuch, aus dem Sie die JSON-Zeichenfolge erstellen möchten,

ist die resultierende JSON-Zeichenkette.

Also die dumps() Methodenabfälle in eine JSON-Zeichenkette .

Zu unserem bestehenden Python-Wörterbuch py_dict. Fügen wir einen neuen Schlüssel hinzu "Filme". Sie können dies wie im folgenden Codeschnipsel dargestellt tun:

py_dict["movies"] = [{"title":"The Imitation Game","year":"2014",
"lang":"en","watched":True}]

Copy

Lassen Sie uns nun das geänderte Wörterbuch in eine neue JSON-Zeichenfolge ausgeben json_str2 unter Verwendung der dumps() Methode.

json_str2 = json.dumps(py_dict)

print(json_str2)

# Output
{"books": [{"title": "The Wind in the Willows", "author": "Kenneth Grahame", "year": "1908"},
{"title": "To the Lighthouse", "author": "Virginia Woolf", "year": "1927"}],
"movies": [{"title": "The Imitation Game", "year": "2014", "lang": "en", "watched": true}]}

Copy

Wie Sie im obigen Beispiel sehen können, ist die ausgegebene JSON-Zeichenfolge ohne angemessene Formatierung schwer zu lesen. Sie können die optional Parameter Einzug um eine Einrückung hinzuzufügen.

Und das können Sie tun, indem Sie Einzug zu einer ganzen Zahl wie 2, wie unten gezeigt:

json_str2 = json.dumps(py_dict, indent = 2)
print(json_str2)

# Output
{
  "books": [
    {
      "title": "The Wind in the Willows",
      "author": "Kenneth Grahame",
      "year": "1908"
    },
    {
      "title": "To the Lighthouse",
      "author": "Virginia Woolf",
      "year": "1927"
    }
  ],
  "movies": [
    {
      "title": "The Imitation Game",
      "year": "2014",
      "lang": "en",
      "watched": true
    }
  ]
}

Copy

Beachten Sie, wie die Ausgabe mit Einrückungen formatiert wurde, und es ist einfach, ihr zu folgen.

Hinweis: 💡 Wenn die Schlüssel in alphabetischer Reihenfolge sortiert werden sollen, können Sie den sort_keys Parameter zu Wahr.

Wie Sie im nachstehenden Codeausschnitt sehen können, wurden die Schlüssel nun in alphabetischer Reihenfolge sortiert.

json_str2 = json.dumps(py_dict, indent = 2, sort_keys=True)
print(json_str2)

# Output
{
  "books": [
    {
      "author": "Kenneth Grahame",
      "title": "The Wind in the Willows",
      "year": "1908"
    },
    {
      "author": "Virginia Woolf",
      "title": "To the Lighthouse",
      "year": "1927"
    }
  ],
  "movies": [
    {
      "lang": "en",
      "title": "The Imitation Game",
      "watched": true,
      "year": "2014"
    }
  ]

Copy

Und die Tasten erscheinen nun in alphabetischer Reihenfolge: "Autor", "Titel" und "Jahr".

Bisher haben Sie gelernt, wie man mit JSON-Strings in Python arbeitet. Im nächsten Abschnitt lernen Sie, wie Sie mit JSON-Dateien arbeiten können.

# data[].attributes.headline
Wie man einen JSON-String in Python lädt

# data[].attributes.subject
Wie man einen JSON-String in Python lädt

# data[].attributes.body
Die allgemeine Syntax zum Laden einer JSON-Zeichenkette in Python lautet:

<dict_obj> = json.loads(<json_str>)

Copy

Hier,

ist das Python-Wörterbuch, in das Sie die JSON-Zeichenfolge laden möchten,

ist eine beliebige gültige JSON-Zeichenkette.

Damit wird die in das Python-Wörterbuch .

Lassen Sie uns ein Beispiel programmieren. Hier json_str ist eine JSON-Zeichenkette.

json_str = '''
{
    "books": [
        {
            "title": "The Wind in the Willows",
            "author": "Kenneth Grahame",
            "year": "1908"
        },
        {
            "title": "To the Lighthouse",
            "author": "Virginia Woolf",
            "year": "1927"
        }
    ]
}
'''

Copy

Der folgende Codeschnipsel zeigt, wie Sie die JSON-Zeichenfolge laden können json_str in ein Python-Wörterbuch unter Verwendung der lädt() Methode. Sie können die eingebaute Typ() Funktion, um zu überprüfen, dass py_dict ist ein Python-Wörterbuch.

py_dict = json.loads(json_str)

type(py_dict)

# Output: dict

print(py_dict)

# Output
{'books': [{'title': 'The Wind in the Willows',
'author': 'Kenneth Grahame', 'year': '1908'},
{'title': 'To the Lighthouse', 'author': 'Virginia Woolf', 'year': '1927'}]}

Copy

Wie im obigen Code gezeigt, sind alle Felder in der JSON-Zeichenkette Schlüssel-Wert-Paare in py_dict.

# data[].attributes.body
CSV-Dateien sind im Grunde genommen einfache Textdateien, die Daten im ASCII-Format ablegen. Dieses einfache Format versteht nahezu jedes Computerprogramm. Wird eine Datenbanktabelle ins CSV-Format übertragen, dann können Daten also auch zwischen eigentlich inkompatiblen Programmen ausgetauscht werden. Eine weitere spezielle Anwendung ist die Passwortdatei der UNIX-Benutzerverwaltung. Hier wird ebenfalls eine CSV-Datei eingesetzt, als Trennzeichen wird hier allerdings kein Semikolon, sondern ein Doppelpunkt verwendet. Zu beachten ist, dass per CSV-Datei nur Text übertragen werden kann. Das Einbetten von Grafiken oder Audiodateien ist nicht möglich.

"NOVALNET"

# data[].attributes.body
Die Python-Werkzeuge zum Arbeiten mit XML stammen im wesentlichen aus drei Paketen. Dies sind, vom meistbenutzten zum größten:

1. Die Python-Standardbibliothek
2. PyXML, hergestellt von der Python XML Special Interest Group
3. 4Suite von Fourthought, Inc.

# data[].attributes.body
HTML wird verwendet, um Daten anzuzeigen und die Struktur einer Webseite zu beschreiben, während XML verwendet wird, um die Daten zu speichern und zu übertragen

# data[].attributes.body
[ˈjæməl]

Dokumentation:

# data[].attributes.attachment_link.readable_text
Revision 1.2.2 (2021-10-01)

Copyright presently by YAML Language Development Team
Copyright 2001-2009 by Oren Ben-Kiki, Clark Evans, Ingy döt Net

This document may be freely copied, provided it is not modified.
Status of this Document
This is the YAML specification v1.2.2. It defines the YAML 1.2 data language. There are no normative changes from the YAML specification v1.2. The primary objectives of this revision are to correct errors and add clarity.

This revision also strives to make the YAML language development process more open, more transparent and easier for people to contribute to. The input format is now Markdown instead of DocBook, and the images are made from plain text LaTeX files rather than proprietary drawing software. All the source content for the specification is publicly hosted.

The previous YAML specification was published 12 years ago. In that time span, YAML's popularity has grown significantly. Efforts are ongoing to improve the language and grow it to meet the needs and expectations of its users. While this revision of the specification makes no actual changes to YAML, it begins a process by which the language intends to evolve and stay modern.

The YAML specification is often seen as overly complicated for something which appears to be so simple. Even though YAML often is used for software configuration, it has always been and will continue to be a complete data serialization language. Future YAML plans are focused on making the language and ecosystem more powerful and reliable while simultaneously simplifying the development process for implementers.

While this revision of the specification is limiting itself to informational changes only, there is companion documentation intended to guide YAML framework implementers and YAML language users. This documentation can continue to evolve and expand continually between published revisions of this specification.

See:
Abstract
YAML™ (rhymes with "camel") is a human-friendly, cross language, Unicode based data serialization language designed around the common native data types of dynamic programming languages. It is broadly useful for programming needs ranging from configuration files to internet messaging to object persistence to data auditing and visualization. Together with the Unicode standard for characters, this specification provides all the information necessary to understand YAML version 1.2 and to create programs that process YAML information.
Contents
YAML (a recursive acronym for "YAML Ain't Markup Language") is a data serialization language designed to be human-friendly and work well with modern programming languages for common everyday tasks. This specification is both an introduction to the YAML language and the concepts supporting it. It is also a complete specification of the information needed to develop applications for processing YAML.

Open, interoperable and readily understandable tools have advanced computing immensely. YAML was designed from the start to be useful and friendly to people working with data. It uses Unicode printable characters, some of which provide structural information and the rest containing the data itself. YAML achieves a unique cleanness by minimizing the amount of structural characters and allowing the data to show itself in a natural and meaningful way. For example, indentation may be used for structure, colons separate key/value pairs and dashes are used to create "bulleted" lists.

There are many kinds of data structures, but they can all be adequately represented with three basic primitives: mappings (hashes/dictionaries), sequences (arrays/lists) and scalars (strings/numbers). YAML leverages these primitives and adds a simple typing system and aliasing mechanism to form a complete language for serializing any native data structure. While most programming languages can use YAML for data serialization, YAML excels in working with those languages that are fundamentally built around the three basic primitives. These include common dynamic languages such as JavaScript, Perl, PHP, Python and Ruby.

There are hundreds of different languages for programming, but only a handful of languages for storing and transferring data. Even though its potential is virtually boundless, YAML was specifically created to work well for common use cases such as: configuration files, log files, interprocess messaging, cross-language data sharing, object persistence and debugging of complex data structures. When data is easy to view and understand, programming becomes a simpler task.

1.1. Goals

The design goals for YAML are, in decreasing priority:

1. YAML should be easily readable by humans.

2. YAML data should be portable between programming languages.

3. YAML should match the native data structures of dynamic languages.

4. YAML should have a consistent model to support generic tools.

5. YAML should support one-pass processing.

6. YAML should be expressive and extensible.

7. YAML should be easy to implement and use.

1.2. YAML History

The YAML 1.0 specification was published in early 2004 by by Clark Evans, Oren Ben-Kiki, and Ingy döt Net after 3 years of collaborative design work through the yaml-core mailing list. The project was initially rooted in Clark and Oren's work on the SML-DEV mailing list (for simplifying XML) and Ingy's plain text serialization module for Perl. The language took a lot of inspiration from many other technologies and formats that preceded it.

The first YAML framework was written in Perl in 2001 and Ruby was the first language to ship a YAML framework as part of its core language distribution in 2003.

The YAML 1.1 specification was published in 2005. Around this time, the developers became aware of JSON. By sheer coincidence, JSON was almost a complete subset of YAML (both syntactically and semantically).

In 2006, Kyrylo Simonov produced PyYAML and LibYAML. A lot of the YAML frameworks in various programming languages are built over LibYAML and many others have looked to PyYAML as a solid reference for their implementations.

The YAML 1.2 specification was published in 2009. Its primary focus was making YAML a strict superset of JSON. It also removed many of the problematic implicit typing recommendations.

Since the release of the 1.2 specification, YAML adoption has continued to grow, and many large-scale projects use it as their primary interface language. In 2020, the new YAML language design team began meeting regularly to discuss improvements to the YAML language and specification; to better meet the needs and expectations of its users and use cases.

This YAML 1.2.2 specification, published in October 2021, is the first step in YAML's rejuvenated development journey. YAML is now more popular than it has ever been, but there is a long list of things that need to be addressed for it to reach its full potential. The YAML design team is focused on making YAML as good as possible.

1.3. Terminology

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.

This section provides a quick glimpse into the expressive power of YAML. It is not expected that the first-time reader grok all of the examples. Rather, these selections are used as motivation for the remainder of the specification.

2.1. Collections

YAML's block collections use indentation for scope and begin each entry on its own line. Block sequences indicate each entry with a dash and space ("- "). Mappings use a colon and space (": ") to mark each key/value pair. Comments begin with an octothorpe (also called a "hash", "sharp", "pound" or "number sign" - "# ").

YAML also has flow styles, using explicit indicators rather than indentation to denote scope. The flow sequence is written as a comma separated list within square brackets. In a similar manner, the flow mapping uses curly braces.

2.2. Structures

YAML uses three dashes ("---") to separate directives from document content. This also serves to signal the start of a document if no directives are present. Three dots ( "... ") indicate the end of a document without starting a new one, for use in communication channels.

Repeated nodes (objects) are first identified by an anchor (marked with the ampersand - "&") and are then aliased (referenced with an asterisk - "* ") thereafter.

A question mark and space ("? ") indicate a complex mapping key. Within a block collection, key/value pairs can start immediately following the dash, colon or question mark.

2.3. Scalars

Scalar content can be written in block notation, using a literal style (indicated by "|") where all line breaks are significant. Alternatively, they can be written with the folded style (denoted by ">") where each line break is folded to a space unless it ends an empty or a more-indented line.

In YAML, untagged nodes are given a type depending on the application. The examples in this specification generally use the seq, map and str types from the fail safe schema. A few examples also use the int, float and null types from the JSON schema.

Explicit typing is denoted with a tag using the exclamation point ("!") symbol. Global tags are URIs and may be specified in a tag shorthand notation using a handle. Application-specific local tags may also be used.

2.5. Full Length Example

Below are two full-length examples of YAML. The first is a sample invoice; the second is a sample log file.

A YAML processor is a tool for converting information between these complementary views. It is assumed that a YAML processor does its work on behalf of another module, called an application. This chapter describes the information structures a YAML processor must provide to or obtain from the application.

3.1. Processes

Translating between native data structures and a character stream is done in several logically distinct stages, each with a well defined input and output data model, as shown in the following diagram:
Figure 3.1. Processing Overview
A YAML processor need not expose the serialization or representation stages. It may translate directly between native data structures and a character stream ( dump and load in the diagram above). However, such a direct translation should take place so that the native data structures are constructed only from information available in the representation. In particular, mapping key order, comments and tag handles should not be referenced during construction.

3.1.1. Dump

Dumping native data structures to a character stream is done using the following three stages:

Representing Native Data Structures

YAML represents any native data structure using three node kinds: sequence - an ordered series of entries; mapping - an unordered association of unique keys to values; and scalar - any datum with opaque structure presentable as a series of Unicode characters.

Each YAML node requires, in addition to its kind and content, a tag specifying its data type. Type specifiers are either global URIs or are local in scope to a single application. For example, an integer is represented in YAML with a scalar plus the global tag " tag:yaml.org,2002:int". Similarly, an invoice object, particular to a given organization, could be represented as a mapping together with the local tag "!invoice ". This simple model can represent any data structure independent of programming language.

Serializing the Representation Graph

For sequential access mediums, such as an event callback API, a YAML representation must be serialized to an ordered tree. Since in a YAML representation, mapping keys are unordered and nodes may be referenced more than once (have more than one incoming "arrow"), the serialization process is required to impose an ordering on the mapping keys and to replace the second and subsequent references to a given node with place holders called aliases. YAML does not specify how these serialization details are chosen. It is up to the YAML processor to come up with human-friendly key order and anchor names, possibly with the help of the application. The result of this process, a YAML serialization tree, can then be traversed to produce a series of event calls for one-pass processing of YAML data.

Presenting the Serialization Tree

The final output process is presenting the YAML serializations as a character stream in a human-friendly manner. To maximize human readability, YAML offers a rich set of stylistic options which go far beyond the minimal functional needs of simple data storage. Therefore the YAML processor is required to introduce various presentation details when creating the stream, such as the choice of node styles, how to format scalar content, the amount of indentation, which tag handles to use, the node tags to leave unspecified, the set of directives to provide and possibly even what comments to add. While some of this can be done with the help of the application, in general this process should be guided by the preferences of the user.

3.1.2. Load

Parsing the Presentation Stream

Parsing is the inverse process of presentation, it takes a stream of characters and produces a serialization tree. Parsing discards all the details introduced in the presentation process, reporting only the serialization tree. Parsing can fail due to ill-formed input.

Composing the Representation Graph

Composing takes a serialization tree and produces a representation graph. Composing discards all the details introduced in the serialization process, producing only the representation graph. Composing can fail due to any of several reasons, detailed below.

Constructing Native Data Structures

The final input process is constructing native data structures from the YAML representation. Construction must be based only on the information available in the representation and not on additional serialization or presentation details such as comments, directives, mapping key order, node styles, scalar content format, indentation levels etc. Construction can fail due to the unavailability of the required native data types.

3.2. Information Models

This section specifies the formal details of the results of the above processes. To maximize data portability between programming languages and implementations, users of YAML should be mindful of the distinction between serialization or presentation properties and those which are part of the YAML representation. Thus, while imposing a order on mapping keys is necessary for flattening YAML representations to a sequential access medium, this serialization detail must not be used to convey application level information. In a similar manner, while indentation technique and a choice of a node style are needed for the human readability, these presentation details are neither part of the YAML serialization nor the YAML representation. By carefully separating properties needed for serialization and presentation, YAML representations of application information will be consistent and portable between various programming environments.

The following diagram summarizes the three information models. Full arrows denote composition, hollow arrows denote inheritance, " 1" and "*" denote "one" and "many" relationships. A single "+" denotes serialization details, a double "++" denotes presentation details.
Figure 3.2. Information Models
3.2.1. Representation Graph

YAML's representation of native data structure is a rooted, connected, directed graph of tagged nodes. By "directed graph" we mean a set of nodes and directed edges ("arrows"), where each edge connects one node to another (see a formal directed graph definition). All the nodes must be reachable from the root node via such edges. Note that the YAML graph may include cycles and a node may have more than one incoming edge.

Nodes that are defined in terms of other nodes are collections; nodes that are independent of any other nodes are scalars. YAML supports two kinds of collection nodes: sequences and mappings. Mapping nodes are somewhat tricky because their keys are unordered and must be unique.
Figure 3.3. Representation Model
3.2.1.1. Nodes

A YAML node represents a single native data structure. Such nodes have content of one of three kinds: scalar, sequence or mapping. In addition, each node has a tag which serves to restrict the set of possible values the content can have.

Scalar

The content of a scalar node is an opaque datum that can be presented as a series of zero or more Unicode characters.

Sequence

The content of a sequence node is an ordered series of zero or more nodes. In particular, a sequence may contain the same node more than once. It could even contain itself.

Mapping

The content of a mapping node is an unordered set of key/value node pairs, with the restriction that each of the keys is unique. YAML places no further restrictions on the nodes. In particular, keys may be arbitrary nodes, the same node may be used as the value of several key/value pairs and a mapping could even contain itself as a key or a value.

YAML represents type information of native data structures with a simple identifier, called a tag. Global tags are URIs and hence globally unique across all applications. The " tag:" URI scheme is recommended for all global YAML tags. In contrast, local tags are specific to a single application. Local tags start with "!", are not URIs and are not expected to be globally unique. YAML provides a " TAG" directive to make tag notation less verbose; it also offers easy migration from local to global tags. To ensure this, local tags are restricted to the URI character set and use URI character escaping.

YAML does not mandate any special relationship between different tags that begin with the same substring. Tags ending with URI fragments (containing "#") are no exception; tags that share the same base URI but differ in their fragment part are considered to be different, independent tags. By convention, fragments are used to identify different "variants" of a tag, while "/" is used to define nested tag "namespace" hierarchies. However, this is merely a convention and each tag may employ its own rules. For example, Perl tags may use "::" to express namespace hierarchies, Java tags may use ". ", etc.

YAML tags are used to associate meta information with each node. In particular, each tag must specify the expected node kind ( scalar, sequence or mapping). Scalar tags must also provide a mechanism for converting formatted content to a canonical form for supporting equality testing. Furthermore, a tag may provide additional information such as the set of allowed content values for validation, a mechanism for tag resolution or any other data that is applicable to all of the tag's nodes.

3.2.1.3. Node Comparison

Since YAML mappings require key uniqueness, representations must include a mechanism for testing the equality of nodes. This is non-trivial since YAML allows various ways to format scalar content. For example, the integer eleven can be written as " 0o13" (octal) or " 0xB" (hexadecimal). If both notations are used as keys in the same mapping, only a YAML processor which recognizes integer formats would correctly flag the duplicate key as an error.

Canonical Form

YAML supports the need for scalar equality by requiring that every scalar tag must specify a mechanism for producing the canonical form of any formatted content. This form is a Unicode character string which also presents the same content and can be used for equality testing.

Equality

Two nodes must have the same tag and content to be equal. Since each tag applies to exactly one kind, this implies that the two nodes must have the same kind to be equal.

Two sequences are equal only when they have the same tag and length and each node in one sequence is equal to the corresponding node in the other sequence.

Two mappings are equal only when they have the same tag and an equal set of keys and each key in this set is associated with equal values in both mappings.

Different URI schemes may define different rules for testing the equality of URIs. Since a YAML processor cannot be reasonably expected to be aware of them all, it must resort to a simple character-by-character comparison of tags to ensure consistency. This also happens to be the comparison method defined by the " tag:" URI scheme. Tags in a YAML stream must therefore be presented in a canonical way so that such comparison would yield the correct results.

If a node has itself as a descendant (via an alias), then determining the equality of that node is implementation-defined.

A YAML processor may treat equal scalars as if they were identical.

Uniqueness

A mapping's keys are unique if no two keys are equal to each other. Obviously, identical nodes are always considered equal.

3.2.2. Serialization Tree

To express a YAML representation using a serial API, it is necessary to impose an order on mapping keys and employ alias nodes to indicate a subsequent occurrence of a previously encountered node. The result of this process is a serialization tree, where each node has an ordered set of children. This tree can be traversed for a serial event-based API. Construction of native data structures from the serial interface should not use key order or anchor names for the preservation of application data.
Figure 3.4. Serialization Model
3.2.2.1. Mapping Key Order

In the representation model, mapping keys do not have an order. To serialize a mapping, it is necessary to impose an ordering on its keys. This order is a serialization detail and should not be used when composing the representation graph (and hence for the preservation of application data). In every case where node order is significant, a sequence must be used. For example, an ordered mapping can be represented as a sequence of mappings, where each mapping is a single key/value pair. YAML provides convenient compact notation for this case.

3.2.2.2. Anchors and Aliases

In the representation graph, a node may appear in more than one collection. When serializing such data, the first occurrence of the node is identified by an anchor. Each subsequent occurrence is serialized as an alias node which refers back to this anchor. Otherwise, anchor names are a serialization detail and are discarded once composing is completed. When composing a representation graph from serialized events, an alias event refers to the most recent event in the serialization having the specified anchor. Therefore, anchors need not be unique within a serialization. In addition, an anchor need not have an alias node referring to it.

3.2.3. Presentation Stream

A YAML presentation is a stream of Unicode characters making use of styles, scalar content formats, comments, directives and other presentation details to present a YAML serialization in a human readable way. YAML allows several serialization trees to be contained in the same YAML presentation stream, as a series of documents separated by markers.
Figure 3.5. Presentation Model
3.2.3.1. Node Styles

Each node is presented in some style, depending on its kind. The node style is a presentation detail and is not reflected in the serialization tree or representation graph. There are two groups of styles. Block styles use indentation to denote structure. In contrast, flow styles rely on explicit indicators.
Figure 3.6. Kind/Style Combinations
3.2.3.2. Scalar Formats

YAML allows scalars to be presented in several formats. For example, the integer " 11" might also be written as " 0xB". Tags must specify a mechanism for converting the formatted content to a canonical form for use in equality testing. Like node style, the format is a presentation detail and is not reflected in the serialization tree and representation graph.

Comments are a presentation detail and must not have any effect on the serialization tree or representation graph. In particular, comments are not associated with a particular node. The usual purpose of a comment is to communicate between the human maintainers of a file. A typical example is comments in a configuration file. Comments must not appear inside scalars, but may be interleaved with such scalars inside collections.

3.2.3.4. Directives

Each document may be associated with a set of directives. A directive has a name and an optional sequence of parameters. Directives are instructions to the YAML processor and like all other presentation details are not reflected in the YAML serialization tree or representation graph. This version of YAML defines two directives, " YAML" and " TAG". All other directives are reserved for future versions of YAML.

The process of loading native data structures from a YAML stream has several potential failure points. The character stream may be ill-formed, aliases may be unidentified, unspecified tags may be unresolvable, tags may be unrecognized, the content may be invalid, mapping keys may not be unique and a native type may be unavailable. Each of these failures results with an incomplete loading.

A partial representation need not resolve the tag of each node and the canonical form of formatted scalar content need not be available. This weaker representation is useful for cases of incomplete knowledge of the types used in the document.
Figure 3.7. Loading Failure Points
3.3.1. Well-Formed Streams and Identified Aliases

A well-formed character stream must match the BNF productions specified in the following chapters. Successful loading also requires that each alias shall refer to a previous node identified by the anchor. A YAML processor should reject ill-formed streams and unidentified aliases. A YAML processor may recover from syntax errors, possibly by ignoring certain parts of the input, but it must provide a mechanism for reporting such errors.

Typically, most tags are not explicitly specified in the character stream. During parsing, nodes lacking an explicit tag are given a non-specific tag: "!" for non- plain scalars and "?" for all other nodes. Composing a complete representation requires each such non-specific tag to be resolved to a specific tag, be it a global tag or a local tag.

Resolving the tag of a node must only depend on the following three parameters: (1) the non-specific tag of the node, (2) the path leading from the root to the node and (3) the content (and hence the kind) of the node. When a node has more than one occurrence (using aliases), tag resolution must depend only on the path to the first ( anchored) occurrence of the node.

Note that resolution must not consider presentation details such as comments, indentation and node style. Also, resolution must not consider the content of any other node, except for the content of the key nodes directly along the path leading from the root to the resolved node. Finally, resolution must not consider the content of a sibling node in a collection or the content of the value node associated with a key node being resolved.

YAML processors should resolve nodes having the "!" non-specific tag as " tag:yaml.org,2002:seq", " tag:yaml.org,2002:map" or " tag:yaml.org,2002:str" depending on their kind. This tag resolution convention allows the author of a YAML character stream to effectively "disable" the tag resolution process. By explicitly specifying a "!" non-specific tag property, the node would then be resolved to a "vanilla" sequence, mapping or string, according to its kind.

Application specific tag resolution rules should be restricted to resolving the "?" non-specific tag, most commonly to resolving plain scalars. These may be matched against a set of regular expressions to provide automatic resolution of integers, floats, timestamps and similar types. An application may also match the content of mapping nodes against sets of expected keys to automatically resolve points, complex numbers and similar types. Resolved sequence node types such as the "ordered mapping" are also possible.

If a document contains unresolved tags, the YAML processor is unable to compose a complete representation graph. In such a case, the YAML processor may compose a partial representation, based on each node's kind and allowing for non-specific tags.

To be valid, a node must have a tag which is recognized by the YAML processor and its content must satisfy the constraints imposed by this tag. If a document contains a scalar node with an unrecognized tag or invalid content, only a partial representation may be composed. In contrast, a YAML processor can always compose a complete representation for an unrecognized or an invalid collection, since collection equality does not depend upon knowledge of the collection's data type. However, such a complete representation cannot be used to construct a native data structure.

In a given processing environment, there need not be an available native type corresponding to a given tag. If a node's tag is unavailable, a YAML processor will not be able to construct a native data structure for it. In this case, a complete representation may still be composed and an application may wish to use this representation directly.

The following chapters formally define the syntax of YAML character streams, using parameterized BNF productions. Each BNF production is both named and numbered for easy reference. Whenever possible, basic structures are specified before the more complex structures using them in a "bottom up" fashion.

The productions are accompanied by examples which are presented in a two-pane side-by-side format. The left-hand side is the YAML example and the right-hand side is an alternate YAML view of the example. The right-hand view uses JSON when possible. Otherwise it uses a YAML form that is as close to JSON as possible.

4.1. Production Syntax

Productions are defined using the syntax production-name ::= term, where a term is either:

An atomic term

A quoted string ("abc"), which matches that concatenation of characters. A single character is usually written with single quotes ('a').

A hexadecimal number (x0A), which matches the character at that Unicode code point.

A range of hexadecimal numbers ([x20-x7E]), which matches any character whose Unicode code point is within that range.

The name of a production (c-printable), which matches that production.

A lookaround

[ lookahead = term ], which matches the empty string if term would match.

[ lookahead ≠ term ], which matches the empty string if term would not match.

[ lookbehind = term ], which matches the empty string if term would match beginning at any prior point on the line and ending at the current position.

A special production

<start-of-line>, which matches the empty string at the beginning of a line.

<end-of-input>, matches the empty string at the end of the input.

<empty>, which (always) matches the empty string.

A parenthesized term

Matches its contents.

A concatenation

Is term-one term-two, which matches term-one followed by term-two.

A alternation

Is term-one | term-two, which matches the term-one if possible, or term-two otherwise.

A quantified term:

term?, which matches (term | <empty>).

term*, which matches (term term* | <empty>).

term+, which matches (term term*).

Note: Quantified terms are always greedy.

The order of precedence is parenthesization, then quantification, then concatenation, then alternation.

Some lines in a production definition might have a comment like:

production-a ::=
  production-b      # clarifying comment

These comments are meant to be informative only. For instance a comment that says # not followed by non-ws char just means that you should be aware that actual production rules will behave as described even though it might not be obvious from the content of that particular production alone.

4.2. Production Parameters

Some productions have parameters in parentheses after the name, such as s-line-prefix(n,c). A parameterized production is shorthand for a (infinite) series of productions, each with a fixed value for each parameter.

For instance, this production:

production-a(n) ::= production-b(n)

Is shorthand for:

production-a(0) ::= production-b(0)
production-a(1) ::= production-b(1)
...

And this production:

production-a(n) ::=
  ( production-b(n+m) production-c(n+m) )+

Is shorthand for:

production-a(0) ::=
    ( production-b(0) production-c(0) )+
  | ( production-b(1) production-c(1) )+
  | ...
production-a(1) ::=
    ( production-b(1) production-c(1) )+
  | ( production-b(2) production-c(2) )+
  | ...
...

The parameters are as follows:

Indentation: n or m

May be any natural number, including zero. n may also be -1.

Context: c

This parameter allows productions to tweak their behavior according to their surrounding. YAML supports two groups of contexts, distinguishing between block styles and flow styles.

May be any of the following values:

BLOCK-IN - inside block context

BLOCK-OUT - outside block context

BLOCK-KEY - inside block key context

FLOW-IN - inside flow context

FLOW-OUT - outside flow context

FLOW-KEY - inside flow key context

(Block) Chomping: t

The line break chomping behavior for flow scalars. May be any of the following values:

STRIP - remove all trailing newlines

CLIP - remove all trailing newlines except the first

KEEP - retain all trailing newlines

4.3. Production Naming Conventions

To make it easier to follow production combinations, production names use a prefix-style naming convention. Each production is given a prefix based on the type of characters it begins and ends with.

e-

A production matching no characters.

c-

A production starting and ending with a special character.

b-

A production matching a single line break.

nb-

A production starting and ending with a non- break character.

s-

A production starting and ending with a white space character.

ns-

A production starting and ending with a non- space character.

l-

A production matching complete line(s).

X-Y-

A production starting with an X- character and ending with a Y- character, where X- and Y- are any of the above prefixes.

X+, X-Y+

A production as above, with the additional property that the matched content indentation level is greater than the specified n parameter.

5.1. Character Set

To ensure readability, YAML streams use only the printable subset of the Unicode character set. The allowed character range explicitly excludes the C0 control block x00-x1F (except for TAB x09, LF x0A and CR x0D which are allowed), DEL x7F, the C1 control block x80-x9F (except for NEL x85 which is allowed), the surrogate block xD800-xDFFF, xFFFE and xFFFF.

On input, a YAML processor must accept all characters in this printable subset.

Note: This isn't mandatory since a full implementation would require extensive character property tables.

[1] c-printable ::=
                         # 8 bit
    x09                  # Tab (\t)
  | x0A                  # Line feed (LF \n)
  | x0D                  # Carriage Return (CR \r)
  | [x20-x7E]            # Printable ASCII
                         # 16 bit
  | x85                  # Next Line (NEL)
  | [xA0-xD7FF]          # Basic Multilingual Plane (BMP)
  | [xE000-xFFFD]        # Additional Unicode Areas
  | [x010000-x10FFFF]    # 32 bit

To ensure JSON compatibility, YAML processors must allow all non-C0 characters inside quoted scalars. To ensure readability, non-printable characters should be escaped on output, even inside such scalars.

Note: JSON quoted scalars cannot span multiple lines or contain tabs, but YAML quoted scalars can.

[2] nb-json ::=
    x09              # Tab character
  | [x20-x10FFFF]    # Non-C0-control characters

Note: The production name nb-json means "non-break JSON compatible" here.

5.2. Character Encodings

All characters mentioned in this specification are Unicode code points. Each such code point is written as one or more bytes depending on the character encoding used. Note that in UTF-16, characters above xFFFF are written as four bytes, using a surrogate pair.

The character encoding is a presentation detail and must not be used to convey content information.

On input, a YAML processor must support the UTF-8 and UTF-16 character encodings. For JSON compatibility, the UTF-32 encodings must also be supported.

If a character stream begins with a byte order mark, the character encoding will be taken to be as indicated by the byte order mark. Otherwise, the stream must begin with an ASCII character. This allows the encoding to be deduced by the pattern of null ( x00) characters.

The encoding can therefore be deduced by matching the first few bytes of the stream with the following table rows (in order):

Byte0

Byte1

Byte2

Byte3

Encoding

The recommended output encoding is UTF-8. If another encoding is used, it is recommended that an explicit byte order mark be used, even if the first stream character is ASCII.

For more information about the byte order mark and the Unicode character encoding schemes see the Unicode FAQ.

[3] c-byte-order-mark ::= xFEFF

In the examples, byte order mark characters are displayed as " ⇔ ".

Example 5.1 Byte Order Mark

⇔# Comment only.

# This stream contains no
# documents, only comments.

Example 5.2 Invalid Byte Order Mark

- Invalid use of BOM
⇔ - Inside a document.

ERROR:
 ABOM must not appear inside a document.

5.3. Indicator Characters

Indicators are characters that have special semantics.

[4] c-sequence-entry ::= '-'

[5] c-mapping-key ::= '?'

[6] c-mapping-value ::= ':'

[7] c-collect-entry ::= ','

[8] c-sequence-start ::= '['

[9] c-sequence-end ::= ']'

[10] c-mapping-start ::= '{'

[11] c-mapping-end ::= '}'

[12] c-comment ::= '#'

[13] c-anchor ::= '&'

[14] c-alias ::= '*'

The "!" ( x21, exclamation) is used for specifying node tags. It is used to denote tag handles used in tag directives and tag properties; to denote local tags; and as the non-specific tag for non- plain scalars.

[15] c-tag ::= '!'

[16] c-literal ::= '|'

[17] c-folded ::= '>'

[18] c-single-quote ::= "'"

[19] c-double-quote ::= '"'

[20] c-directive ::= '%'

The "@" ( x40, at) and "&grave;" ( x60, grave accent) are reserved for future use.

[21] c-reserved ::=
    '@' | '`'

Example 5.10 Invalid use of Reserved Indicators

ERROR:
Reserved indicators can't start a plain scalar.

Any indicator character:

[22] c-indicator ::=
c-sequence-entry # '-' |c-mapping-key # '?' |c-mapping-value # ':' |c-collect-entry # ',' |c-sequence-start # '[' |c-sequence-end # ']' |c-mapping-start # '{' |c-mapping-end # '}' |c-comment # '#' |c-anchor # '&' |c-alias # '*' |c-tag # '!' |c-literal # '|' |c-folded # '>' |c-single-quote # "'" |c-double-quote # '"' |c-directive # '%' |c-reserved # '@' '`'

The "[", "]", "{", "}" and "," indicators denote structure in flow collections. They are therefore forbidden in some cases, to avoid ambiguity in several constructs. This is handled on a case-by-case basis by the relevant productions.

5.4. Line Break Characters

YAML recognizes the following ASCII line break characters.

[24] b-line-feed ::= x0A

[25] b-carriage-return ::= x0D

[26] b-char ::=
b-line-feed # x0A |b-carriage-return # X0D

All other characters, including the form feed ( x0C), are considered to be non-break characters. Note that these include the non-ASCII line breaks: next line ( x85), line separator ( x2028) and paragraph separator ( x2029).

Line breaks are interpreted differently by different systems and have multiple widely used formats.

Line breaks inside scalar content must be normalized by the YAML processor. Each such line break must be parsed into a single line feed character. The original line break format is a presentation detail and must not be used to convey content information.

[29] b-as-line-feed ::=
b-break

Outside scalar content, YAML allows any line break to be used to terminate lines.

[30] b-non-content ::=
b-break

On output, a YAML processor is free to emit line breaks using whatever convention is most appropriate.

In the examples, line breaks are sometimes displayed using the " ↓ " glyph for clarity.

5.5. White Space Characters

YAML recognizes two white space characters: space and tab.

[31] s-space ::= x20

[32] s-tab ::= x09

[33] s-white ::=
s-space | s-tab

The rest of the ( printable) non- break characters are considered to be non-space characters.

[34] ns-char ::=
nb-char - s-white

In the examples, tab characters are displayed as the glyph " →". Space characters are sometimes displayed as the glyph " · " for clarity.

5.6. Miscellaneous Characters

The YAML syntax productions make use of the following additional character classes:

A decimal digit for numbers:

[35] ns-dec-digit ::=
  [x30-x39]             # 0-9

A hexadecimal digit for escape sequences:

[36] ns-hex-digit ::=
ns-dec-digit # 0-9 | [x41-x46] # A-F | [x61-x66] # a-f

ASCII letter (alphabetic) characters:

[37] ns-ascii-letter ::=
    [x41-x5A]           # A-Z
  | [x61-x7A]           # a-z

Word (alphanumeric) characters for identifiers:

[38] ns-word-char ::=
ns-dec-digit # 0-9 |ns-ascii-letter # A-Z a-z | '-' # '-'

URI characters for tags, as defined in the URI specification.

By convention, any URI characters other than the allowed printable ASCII characters are first encoded in UTF-8 and then each byte is escaped using the "%" character. The YAML processor must not expand such escaped characters. Tag characters must be preserved and compared exactly as presented in the YAML stream, without any processing.

[39] ns-uri-char ::=
    (
      '%'
ns-hex-digit{2} ) |ns-word-char | '#' | ';' | '/' | '?' | ':' | '@' | '&' | '=' | '+' | '$' | ',' | '_' | '.' | '!' | '~' | '*' | "'" | '(' | ')' | '[' | ']'

The "!" character is used to indicate the end of a named tag handle; hence its use in tag shorthands is restricted. In addition, such shorthands must not contain the "[", "]", "{", "}" and "," characters. These characters would cause ambiguity with flow collection structures.

5.7. Escaped Characters

All non- printable characters must be escaped. YAML escape sequences use the "\" notation common to most modern computer languages. Each escape sequence must be parsed into the appropriate Unicode character. The original escape sequence is a presentation detail and must not be used to convey content information.

Note that escape sequences are only interpreted in double-quoted scalars. In all other scalar styles, the "\" character has no special meaning and non- printable characters are not available.

[41] c-escape ::= '\'

YAML escape sequences are a superset of C's escape sequences:

Escaped ASCII null ( x00) character.

[42] ns-esc-null ::= '0'

Escaped ASCII bell ( x07) character.

[43] ns-esc-bell ::= 'a'

Escaped ASCII backspace ( x08) character.

[44] ns-esc-backspace ::= 'b'

Escaped ASCII horizontal tab ( x09) character. This is useful at the start or the end of a line to force a leading or trailing tab to become part of the content.

[45] ns-esc-horizontal-tab ::=
  't' | x09

Escaped ASCII line feed ( x0A) character.

[46] ns-esc-line-feed ::= 'n'

Escaped ASCII vertical tab ( x0B) character.

[47] ns-esc-vertical-tab ::= 'v'

Escaped ASCII form feed ( x0C) character.

[48] ns-esc-form-feed ::= 'f'

Escaped ASCII carriage return ( x0D) character.

[49] ns-esc-carriage-return ::= 'r'

Escaped ASCII escape ( x1B) character.

[50] ns-esc-escape ::= 'e'

Escaped ASCII space ( x20) character. This is useful at the start or the end of a line to force a leading or trailing space to become part of the content.

[51] ns-esc-space ::= x20

Escaped ASCII double quote ( x22).

[52] ns-esc-double-quote ::= '"'

Escaped ASCII slash ( x2F), for JSON compatibility.

[53] ns-esc-slash ::= '/'

Escaped ASCII back slash ( x5C).

[54] ns-esc-backslash ::= '\'

Escaped Unicode next line ( x85) character.

[55] ns-esc-next-line ::= 'N'

Escaped Unicode non-breaking space ( xA0) character.

[56] ns-esc-non-breaking-space ::= '_'

Escaped Unicode line separator ( x2028) character.

[57] ns-esc-line-separator ::= 'L'

Escaped Unicode paragraph separator ( x2029) character.

[58] ns-esc-paragraph-separator ::= 'P'

Escaped 8-bit Unicode character.

[59] ns-esc-8-bit ::=
  'x'
ns-hex-digit{2}

Escaped 16-bit Unicode character.

[60] ns-esc-16-bit ::=
  'u'
ns-hex-digit{4}

Escaped 32-bit Unicode character.

[61] ns-esc-32-bit ::=
  'U'
ns-hex-digit{8}

Any escaped character:

[62] c-ns-esc-char ::=
c-escape # '\' (ns-esc-null |ns-esc-bell |ns-esc-backspace |ns-esc-horizontal-tab |ns-esc-line-feed |ns-esc-vertical-tab |ns-esc-form-feed |ns-esc-carriage-return |ns-esc-escape |ns-esc-space |ns-esc-double-quote |ns-esc-slash |ns-esc-backslash |ns-esc-next-line |ns-esc-non-breaking-space |ns-esc-line-separator |ns-esc-paragraph-separator |ns-esc-8-bit |ns-esc-16-bit |ns-esc-32-bit )

Example 5.14 Invalid Escaped Characters

6.1. Indentation Spaces

In YAML block styles, structure is determined by indentation. In general, indentation is defined as a zero or more space characters at the start of a line.

The amount of indentation is a presentation detail and must not be used to convey content information.

[63]
s-indent(0) ::=
  <empty>

# When n≥0
s-indent(n+1) ::=
s-space s-indent(n)

A block style construct is terminated when encountering a line which is less indented than the construct. The productions use the notation " s-indent-less-than(n)" and " s-indent-less-or-equal(n) " to express this.

[64]
s-indent-less-than(1) ::=
  <empty>

# When n≥1
s-indent-less-than(n+1) ::=
s-space s-indent-less-than(n) | <empty>

[65]
s-indent-less-or-equal(0) ::=
  <empty>

# When n≥0
s-indent-less-or-equal(n+1) ::=
s-space s-indent-less-or-equal(n) | <empty>

Each node must be indented further than its parent node. All sibling nodes must use the exact same indentation level. However the content of each sibling node may be further indented independently.

The "-", "?" and ":" characters used to denote block collection entries are perceived by people to be part of the indentation. This is handled on a case-by-case basis by the relevant productions.

6.2. Separation Spaces

Outside indentation and scalar content, YAML uses white space characters for separation between tokens within a line. Note that such white space may safely include tab characters.

Separation spaces are a presentation detail and must not be used to convey content information.

[66] s-separate-in-line ::=
s-white+ | <start-of-line>

6.3. Line Prefixes

Inside scalar content, each line begins with a non- content line prefix. This prefix always includes the indentation. For flow scalar styles it additionally includes all leading white space, which may contain tab characters.

Line prefixes are a presentation detail and must not be used to convey content information.

[68] s-block-line-prefix(n) ::=
s-indent(n)

[69] s-flow-line-prefix(n) ::=
s-indent(n)s-separate-in-line?

6.4. Empty Lines

An empty line line consists of the non- content prefix followed by a line break.

The semantics of empty lines depend on the scalar style they appear in. This is handled on a case-by-case basis by the relevant productions.

6.5. Line Folding

Line folding allows long lines to be broken for readability, while retaining the semantics of the original long line. If a line break is followed by an empty line, it is trimmed; the first line break is discarded and the rest are retained as content.

[71] b-l-trimmed(n,c) ::=
b-non-contentl-empty(n,c)+

Otherwise (the following line is not empty), the line break is converted to a single space ( x20).

[72] b-as-space ::=
b-break

A folded non- empty line may end with either of the above line breaks.

[73] b-l-folded(n,c) ::=
b-l-trimmed(n,c) | b-as-space

The above rules are common to both the folded block style and the scalar flow styles. Folding does distinguish between these cases in the following way:

Block Folding

In the folded block style, the final line break and trailing empty lines are subject to chomping and are never folded. In addition, folding does not apply to line breaks surrounding text lines that contain leading white space. Note that such a more-indented line may consist only of such leading white space.

The combined effect of the block line folding rules is that each "paragraph" is interpreted as a line, empty lines are interpreted as a line feed and the formatting of more-indented lines is preserved.

Flow Folding

Folding in flow styles provides more relaxed semantics. Flow styles typically depend on explicit indicators rather than indentation to convey structure. Hence spaces preceding or following the text in a line are a presentation detail and must not be used to convey content information. Once all such spaces have been discarded, all line breaks are folded without exception.

The combined effect of the flow line folding rules is that each "paragraph" is interpreted as a line, empty lines are interpreted as line feeds and text can be freely more-indented without affecting the content information.

An explicit comment is marked by a "#" indicator. Comments are a presentation detail and must not be used to convey content information.

Comments must be separated from other tokens by white space characters.

Note: To ensure JSON compatibility, YAML processors must allow for the omission of the final comment line break of the input stream. However, as this confuses many tools, YAML processors should terminate the stream with an explicit line break on output.

[75] c-nb-comment-text ::=
c-comment # '#'nb-char*

[76] b-comment ::=
b-non-content | <end-of-input>

In most cases, when a line may end with a comment, YAML allows it to be followed by additional comment lines. The only exception is a comment ending a block scalar header.

[79] s-l-comments ::=
  (
s-b-comment | <start-of-line> )l-comment*

6.7. Separation Lines

Implicit keys are restricted to a single line. In all other cases, YAML allows tokens to be separated by multi-line (possibly empty) comments.

Note that structures following multi-line comment separation must be properly indented, even though there is no such restriction on the separation comment lines themselves.

6.8. Directives

Directives are instructions to the YAML processor. This specification defines two directives, " YAML" and " TAG", and reserves all other directives for future use. There is no way to define private directives. This is intentional.

Directives are a presentation detail and must not be used to convey content information.

Each directive is specified on a separate non- indented line starting with the "%" indicator, followed by the directive name and a list of parameters. The semantics of these parameters depends on the specific directive. A YAML processor should ignore unknown directives with an appropriate warning.

[84] ns-directive-name ::=
ns-char+

[85] ns-directive-parameter ::=
ns-char+

6.8.1. "YAML" Directives

The " YAML" directive specifies the version of YAML the document conforms to. This specification defines version " 1.2", including recommendations for YAML 1.1 processing.

A version 1.2 YAML processor must accept documents with an explicit "%YAML 1.2" directive, as well as documents lacking a " YAML" directive. Such documents are assumed to conform to the 1.2 version specification. Documents with a " YAML" directive specifying a higher minor version (e.g. "%YAML 1.3") should be processed with an appropriate warning. Documents with a " YAML" directive specifying a higher major version (e.g. "%YAML 2.0 ") should be rejected with an appropriate error message.

A version 1.2 YAML processor must also accept documents with an explicit "%YAML 1.1" directive. Note that version 1.2 is mostly a superset of version 1.1, defined for the purpose of ensuring JSON compatibility. Hence a version 1.2 processor should process version 1.1 documents as if they were version 1.2, giving a warning on points of incompatibility (handling of non-ASCII line breaks, as described above).

[86] ns-yaml-directive ::=
  "YAML"
s-separate-in-linens-yaml-version

[87] ns-yaml-version ::=
ns-dec-digit+ '.'ns-dec-digit+

Example 6.14 "YAML" directive

It is an error to specify more than one " YAML " directive for the same document, even if both occurrences give the same version number.

Example 6.15 Invalid Repeated YAML directive

%YAML 1.2
%YAML 1.1 foo

ERROR:
TheYAML directive must only be given at most once per document.

6.8.2. "TAG" Directives

The " TAG" directive establishes a tag shorthand notation for specifying node tags. Each " TAG" directive associates a handle with a prefix. This allows for compact and readable tag notation.

Example 6.16 "TAG" directive

It is an error to specify more than one " TAG" directive for the same handle in the same document, even if both occurrences give the same prefix.

Example 6.17 Invalid Repeated TAG directive

%TAG ! !foo
%TAG! !foo bar

ERROR:
The TAG directive must only
be given at most once per
handle in the same document.

6.8.2.1. Tag Handles

The tag handle exactly matches the prefix of the affected tag shorthand. There are three tag handle variants:

Primary Handle

The primary tag handle is a single "!" character. This allows using the most compact possible notation for a single "primary" name space. By default, the prefix associated with this handle is "!". Thus, by default, shorthands using this handle are interpreted as local tags.

It is possible to override the default behavior by providing an explicit " TAG" directive, associating a different prefix for this handle. This provides smooth migration from using local tags to using global tags by the simple addition of a single " TAG " directive.

[90] c-primary-tag-handle ::= '!'

Secondary Handle

The secondary tag handle is written as "!!". This allows using a compact notation for a single "secondary" name space. By default, the prefix associated with this handle is " tag:yaml.org,2002: ".

It is possible to override this default behavior by providing an explicit " TAG " directive associating a different prefix for this handle.

[91] c-secondary-tag-handle ::= "!!"

Named Handles

A named tag handle surrounds a non-empty name with "!" characters. A handle name must not be used in a tag shorthand unless an explicit " TAG " directive has associated some prefix with it.

The name of the handle is a presentation detail and must not be used to convey content information. In particular, the YAML processor need not preserve the handle name once parsing is completed.

6.8.2.2. Tag Prefixes

There are two tag prefix variants:

[93] ns-tag-prefix ::=
c-ns-local-tag-prefix | ns-global-tag-prefix

Local Tag Prefix

If the prefix begins with a "!" character, shorthands using the handle are expanded to a local tag. Note that such a tag is intentionally not a valid URI and its semantics are specific to the application. In particular, two documents in the same stream may assign different semantics to the same local tag.

[94] c-ns-local-tag-prefix ::=
c-tag # '!'ns-uri-char*

Global Tag Prefix

If the prefix begins with a character other than "!", it must be a valid URI prefix, and should contain at least the scheme. Shorthands using the associated handle are expanded to globally unique URI tags and their semantics is consistent across applications. In particular, every document in every stream must assign the same semantics to the same global tag.

[95] ns-global-tag-prefix ::=
ns-tag-charns-uri-char*

Example 6.22 Global Tag Prefix

%TAG !e!tag:example.com,2000:app/ --- - !e!foo "bar"

- !<tag:example.com,2000:app/foo> "bar"

6.9. Node Properties

Each node may have two optional properties, anchor and tag, in addition to its content. Node properties may be specified in any order before the node's content. Either or both may be omitted.

The tag property identifies the type of the native data structure presented by the node. A tag is denoted by the "! " indicator.

Verbatim Tags

A tag may be written verbatim by surrounding it with the "<" and ">" characters. In this case, the YAML processor must deliver the verbatim tag as-is to the application. In particular, verbatim tags are not subject to tag resolution. A verbatim tag must either begin with a "!" (a local tag) or be a valid URI (a global tag).

[98] c-verbatim-tag ::=
  "!<"
ns-uri-char+ '>'

Tag Shorthands

A tag shorthand consists of a valid tag handle followed by a non-empty suffix. The tag handle must be associated with a prefix, either by default or by using a " TAG" directive. The resulting parsed tag is the concatenation of the prefix and the suffix and must either begin with "!" (a local tag) or be a valid URI (a global tag).

The choice of tag handle is a presentation detail and must not be used to convey content information. In particular, the tag handle may be discarded once parsing is completed.

The suffix must not contain any "!" character. This would cause the tag shorthand to be interpreted as having a named tag handle. In addition, the suffix must not contain the "[", "]", "{", "}" and "," characters. These characters would cause ambiguity with flow collection structures. If the suffix needs to specify any of the above restricted characters, they must be escaped using the "% " character. This behavior is consistent with the URI character escaping rules (specifically, section 2.3 of URI RFC).

[99] c-ns-shorthand-tag ::=
c-tag-handlens-tag-char+

Example 6.27 Invalid Tag Shorthands

Non-Specific Tags

If a node has no tag property, it is assigned a non-specific tag that needs to be resolved to a specific one. This non-specific tag is "!" for non- plain scalars and "?" for all other nodes. This is the only case where the node style has any effect on the content information.

It is possible for the tag property to be explicitly set to the "!" non-specific tag. By convention, this "disables" tag resolution, forcing the node to be interpreted as " tag:yaml.org,2002:seq", " tag:yaml.org,2002:map" or " tag:yaml.org,2002:str", according to its kind.

There is no way to explicitly specify the "? " non-specific tag. This is intentional.

[100] c-non-specific-tag ::= '!'

6.9.2. Node Anchors

An anchor is denoted by the "&" indicator. It marks a node for future reference. An alias node can then be used to indicate additional inclusions of the anchored node. An anchored node need not be referenced by any alias nodes; in particular, it is valid for all nodes to be anchored.

[101] c-ns-anchor-property ::=
c-anchor # '&'ns-anchor-name

Note that as a serialization detail, the anchor name is preserved in the serialization tree. However, it is not reflected in the representation graph and must not be used to convey content information. In particular, the YAML processor need not preserve the anchor name once the representation is composed.

Anchor names must not contain the "[", "]", "{", "}" and "," characters. These characters would cause ambiguity with flow collection structures.

[102] ns-anchor-char ::=
ns-char - c-flow-indicator

[103] ns-anchor-name ::=
ns-anchor-char+

7.1. Alias Nodes

Subsequent occurrences of a previously serialized node are presented as alias nodes. The first occurrence of the node must be marked by an anchor to allow subsequent occurrences to be presented as alias nodes.

An alias node is denoted by the "*" indicator. The alias refers to the most recent preceding node having the same anchor. It is an error for an alias node to use an anchor that does not previously occur in the document. It is not an error to specify an anchor that is not used by any alias node.

[104] c-ns-alias-node ::=
c-alias # '*'ns-anchor-name

7.2. Empty Nodes

YAML allows the node content to be omitted in many cases. Nodes with empty content are interpreted as if they were plain scalars with an empty value. Such nodes are commonly resolved to a " null " value.

[105] e-scalar ::= ""

In the examples, empty scalars are sometimes displayed as the glyph " °" for clarity. Note that this glyph corresponds to a position in the characters stream rather than to an actual character.

Both the node's properties and node content are optional. This allows for a completely empty node. Completely empty nodes are only valid when following some explicit indication for their existence.

[106] e-node ::=
e-scalar # ""

7.3. Flow Scalar Styles

YAML provides three flow scalar styles: double-quoted, single-quoted and plain (unquoted). Each provides a different trade-off between readability and expressive power.

The scalar style is a presentation detail and must not be used to convey content information, with the exception that plain scalars are distinguished for the purpose of tag resolution.

7.3.1. Double-Quoted Style

The double-quoted style is specified by surrounding """ indicators. This is the only style capable of expressing arbitrary strings, by using "\" escape sequences. This comes at the cost of having to escape the "\" and "" " characters.

[108] ns-double-char ::=
nb-double-char - s-white

Double-quoted scalars are restricted to a single line when contained inside an implicit key.

[111] nb-double-one-line ::=
nb-double-char*

In a multi-line double-quoted scalar, line breaks are subject to flow line folding, which discards any trailing white space characters. It is also possible to escape the line break character. In this case, the escaped line break is excluded from the content and any trailing white space characters that precede the escaped line break are preserved. Combined with the ability to escape white space characters, this allows double-quoted lines to be broken at arbitrary positions.

[113] s-double-break(n) ::=
s-double-escaped(n) |s-flow-folded(n)

[114] nb-ns-double-in-line ::=
  (
s-white*ns-double-char )*

7.3.2. Single-Quoted Style

The single-quoted style is specified by surrounding "'" indicators. Therefore, within a single-quoted scalar, such characters need to be repeated. This is the only form of escaping performed in single-quoted scalars. In particular, the "\" and """ characters may be freely used. This restricts single-quoted scalars to printable characters. In addition, it is only possible to break a long single-quoted line where a space character is surrounded by non- spaces.

[117] c-quoted-quote ::= "''"

[119] ns-single-char ::=
nb-single-char - s-white

Single-quoted scalars are restricted to a single line when contained inside a implicit key.

[122] nb-single-one-line ::=
nb-single-char*

[123] nb-ns-single-in-line ::=
  (
s-white*ns-single-char )*

7.3.3. Plain Style

The plain (unquoted) style has no identifying indicators and provides no form of escaping. It is therefore the most readable, most limited and most context sensitive style. In addition to a restricted character set, a plain scalar must not be empty or contain leading or trailing white space characters. It is only possible to break a long plain line where a space character is surrounded by non- spaces.

Plain scalars must not begin with most indicators, as this would cause ambiguity with other YAML constructs. However, the ":", "?" and "-" indicators may be used as the first character if followed by a non- space "safe" character, as this causes no ambiguity.

Plain scalars must never contain the ": " and " #" character combinations. Such combinations would cause ambiguity with mapping key/value pairs and comments. In addition, inside flow collections, or when used as implicit keys, plain scalars must not contain the "[", "]", "{", "}" and "," characters. These characters would cause ambiguity with flow collection structures.

[128] ns-plain-safe-out ::=
ns-char

[129] ns-plain-safe-in ::=
ns-char - c-flow-indicator

[130] ns-plain-char(c) ::=
    (
ns-plain-safe(c) -c-mapping-value # ':' -c-comment # '#' ) | ( [ lookbehind =ns-char ]c-comment # '#' ) | (c-mapping-value # ':' [ lookahead =ns-plain-safe(c) ] )

Plain scalars are further restricted to a single line when contained inside an implicit key.

[132] nb-ns-plain-in-line(c) ::=
  (
s-white*ns-plain-char(c) )*

[133] ns-plain-one-line(c) ::=
ns-plain-first(c)nb-ns-plain-in-line(c)

[135] ns-plain-multi-line(n,c) ::=
ns-plain-one-line(c)s-ns-plain-next-line(n,c)*

7.4. Flow Collection Styles

A flow collection may be nested within a block collection ([ FLOW-OUT context]), nested within another flow collection ([ FLOW-IN context]) or be a part of an implicit key ([ FLOW-KEY context] or [ BLOCK-KEY context]). Flow collection entries are terminated by the "," indicator. The final "," may be omitted. This does not cause ambiguity because flow collection entries can never be completely empty.

7.4.1. Flow Sequences

Flow sequence content is denoted by surrounding "[" and "] " characters.

Sequence entries are separated by a ", " character.

[139] ns-flow-seq-entry(n,c) ::=
ns-flow-pair(n,c) | ns-flow-node(n,c)

7.4.2. Flow Mappings

Flow mappings are denoted by surrounding "{" and "} " characters.

Mapping entries are separated by a ", " character.

If the optional "?" mapping key indicator is specified, the rest of the entry may be completely empty.

Normally, YAML insists the ":" mapping value indicator be separated from the value by white space. A benefit of this restriction is that the ":" character can be used inside plain scalars, as long as it is not followed by white space. This allows for unquoted URLs and timestamps. It is also a potential source for confusion as " a:1" is a plain scalar and not a key/value pair.

Note that the value may be completely empty since its existence is indicated by the ": ".

[146] c-ns-flow-map-empty-key-entry(n,c) ::=
e-node # ""c-ns-flow-map-separate-value(n,c)

To ensure JSON compatibility, if a key inside a flow mapping is JSON-like, YAML allows the following value to be specified adjacent to the ":". This causes no ambiguity, as all JSON-like keys are surrounded by indicators. However, as this greatly reduces readability, YAML processors should separate the value from the ": " on output, even in this case.

A more compact notation is usable inside flow sequences, if the mapping contains a single key/value pair. This notation does not require the surrounding "{" and "}" characters. Note that it is not possible to specify any node properties for the mapping in this case.

If the "?" indicator is explicitly specified, parsing is unambiguous and the syntax is identical to the general case.

If the "?" indicator is omitted, parsing needs to see past the implicit key to recognize it as such. To limit the amount of lookahead required, the ":" indicator must appear at most 1024 Unicode characters beyond the start of the key. In addition, the key is restricted to a single line.

[152] ns-flow-pair-yaml-key-entry(n,c) ::=
ns-s-implicit-yaml-key(FLOW-KEY)c-ns-flow-map-separate-value(n,c)

[153] c-ns-flow-pair-json-key-entry(n,c) ::=
c-s-implicit-json-key(FLOW-KEY)c-ns-flow-map-adjacent-value(n,c)

[154] ns-s-implicit-yaml-key(c) ::=
ns-flow-yaml-node(0,c)s-separate-in-line? /* At most 1024 characters altogether */

[155] c-s-implicit-json-key(c) ::=
c-flow-json-node(0,c)s-separate-in-line? /* At most 1024 characters altogether */

Example 7.22 Invalid Implicit Keys

7.5. Flow Nodes

JSON-like flow styles all have explicit start and end indicators. The only flow style that does not have this property is the plain scalar. Note that none of the "JSON-like" styles is actually acceptable by JSON. Even the double-quoted style is a superset of the JSON string format.

[156] ns-flow-yaml-content(n,c) ::=
ns-plain(n,c)

[158] ns-flow-content(n,c) ::=
ns-flow-yaml-content(n,c) |c-flow-json-content(n,c)

8.1. Block Scalar Styles

Block scalars are controlled by a few indicators given in a header preceding the content itself. This header is followed by a non-content line break with an optional comment. This is the only case where a comment must not be followed by additional comment lines.

Note: See Production Parameters for the definition of the t variable.

8.1.1.1. Block Indentation Indicator

Every block scalar has a content indentation level. The content of the block scalar excludes a number of leading spaces on each line up to the content indentation level.

If a block scalar has an indentation indicator, then the content indentation level of the block scalar is equal to the indentation level of the block scalar plus the integer value of the indentation indicator character.

It is an error if any non- empty line does not begin with a number of spaces greater than or equal to the content indentation level.

A YAML processor should only emit an explicit indentation indicator for cases where detection will fail.

[163] c-indentation-indicator ::=
  [x31-x39]    # 1-9

Example 8.3 Invalid Block Scalar Indentation Indicators

8.1.1.2. Block Chomping Indicator

Strip

Stripping is specified by the "-" chomping indicator. In this case, the final line break and any trailing empty lines are excluded from the scalar's content.

Clip

Clipping is the default behavior used if no explicit chomping indicator is specified. In this case, the final line break character is preserved in the scalar's content. However, any trailing empty lines are excluded from the scalar's content.

Keep

Keeping is specified by the "+" chomping indicator. In this case, the final line break and any trailing empty lines are considered to be part of the scalar's content. These additional lines are not subject to folding.

The chomping method used is a presentation detail and must not be used to convey content information.

[164]
c-chomping-indicator(STRIP) ::= '-'
c-chomping-indicator(KEEP)  ::= '+'
c-chomping-indicator(CLIP)  ::= ""

[168] l-keep-empty(n) ::=
l-empty(n,BLOCK-IN)*l-trail-comments(n)?

Explicit comment lines may follow the trailing empty lines. To prevent ambiguity, the first such comment line must be less indented than the block scalar content. Additional comment lines, if any, are not so restricted. This is the only case where the indentation of comment lines is constrained.

If a block scalar consists only of empty lines, then these lines are considered as trailing lines and hence are affected by chomping.

8.1.2. Literal Style

The literal style is denoted by the "|" indicator. It is the simplest, most restricted and most readable scalar style.

Inside literal scalars, all ( indented) characters are considered to be content, including white space characters. Note that all line break characters are normalized. In addition, empty lines are not folded, though final line breaks and trailing empty lines are chomped.

There is no way to escape characters inside literal scalars. This restricts them to printable characters. In addition, there is no way to break a long literal line.

[172] b-nb-literal-next(n) ::=
b-as-line-feedl-nb-literal-text(n)

8.1.3. Folded Style

The folded style is denoted by the ">" indicator. It is similar to the literal style; however, folded scalars are subject to line folding.

(The following three examples duplicate this example, each highlighting different productions.)

Lines starting with white space characters ( more-indented lines) are not folded.

[178] b-l-spaced(n) ::=
b-as-line-feedl-empty(n,BLOCK-IN)*

8.2. Block Collection Styles

For readability, block collections styles are not denoted by any indicator. Instead, YAML uses a lookahead method, where a block collection is distinguished from a plain scalar only when a key/value pair or a sequence entry is seen.

8.2.1. Block Sequences

A block sequence is simply a series of nodes, each denoted by a leading "-" indicator. The "-" indicator must be separated from the node by white space. This allows "-" to be used as the first character in a plain scalar if followed by a non-space character (e.g. "-42 ").

[183] l+block-sequence(n) ::=
  (
s-indent(n+1+m)c-l-block-seq-entry(n+1+m) )+

The entry node may be either completely empty, be a nested block node or use a compact in-line notation. The compact notation may be used when the entry is itself a nested block collection. In this case, both the "-" indicator and the following spaces are considered to be part of the indentation of the nested collection. Note that it is not possible to specify node properties for such a collection.

8.2.2. Block Mappings

[187] l+block-mapping(n) ::=
  (
s-indent(n+1+m)ns-l-block-map-entry(n+1+m) )+

If the "?" indicator is specified, the optional value node must be specified on a separate line, denoted by the ":" indicator. Note that YAML allows here the same compact in-line notation described above for block sequence entries.

[188] ns-l-block-map-entry(n) ::=
c-l-block-map-explicit-entry(n) |ns-l-block-map-implicit-entry(n)

[190] c-l-block-map-explicit-key(n) ::=
c-mapping-key # '?' (not followed by non-ws char)s-l+block-indented(n,BLOCK-OUT)

If the "?" indicator is omitted, parsing needs to see past the implicit key, in the same way as in the single key/value pair flow mapping. Hence, such keys are subject to the same restrictions; they are limited to a single line and must not span more than 1024 Unicode characters.

[193] ns-s-block-map-implicit-key ::=
c-s-implicit-json-key(BLOCK-KEY) |ns-s-implicit-yaml-key(BLOCK-KEY)

In this case, the value may be specified on the same line as the implicit key. Note however that in block mappings the value must never be adjacent to the ":", as this greatly reduces readability and is not required for JSON compatibility (unlike the case in flow mappings).

There is no compact notation for in-line values. Also, while both the implicit key and the value following it may be empty, the ":" indicator is mandatory. This prevents a potential ambiguity with multi-line plain scalars.

8.2.3. Block Nodes

YAML allows flow nodes to be embedded inside block collections (but not vice-versa). Flow nodes must be indented by at least one more space than the parent block collection. Note that flow nodes may begin on a following line.

[196] s-l+block-node(n,c) ::=
s-l+block-in-block(n,c) |s-l+flow-in-block(n)

[198] s-l+block-in-block(n,c) ::=
s-l+block-scalar(n,c) |s-l+block-collection(n,c)

Since people perceive the "-" indicator as indentation, nested block sequences may be indented by one less space to compensate, except, of course, if nested inside another block sequence ([ BLOCK-OUT context] versus [ BLOCK-IN context]).

[201] seq-space(n,BLOCK-OUT) ::=l+block-sequence(n-1) seq-space(n,BLOCK-IN) ::=l+block-sequence(n)

9.1. Documents

A YAML character stream may contain several documents. Each document is completely independent from the rest.

9.1.1. Document Prefix

The existence of the optional prefix does not necessarily indicate the existence of an actual document.

[202] l-document-prefix ::=
c-byte-order-mark?l-comment*

9.1.2. Document Markers

Using directives creates a potential ambiguity. It is valid to have a "%" character at the start of a line (e.g. as the first character of the second line of a plain scalar). How, then, to distinguish between an actual directive and a content line that happens to start with a "% " character?

At the start of a document, lines beginning with a "%" character are assumed to be directives. The (possibly empty) list of directives is terminated by a directives end marker line. Lines following this marker can safely use "% " as the first character.

At the end of a document, a document end marker line is used to signal the parser to begin scanning for directives again.

The existence of this optional document suffix does not necessarily indicate the existence of an actual following document.

Obviously, the actual content lines are therefore forbidden to begin with either of these markers.

[203] c-directives-end ::= "---"

[204] c-document-end ::=
  "..."    # (not followed by non-ws char)

[205] l-document-suffix ::=
c-document-ends-l-comments

9.1.3. Bare Documents

A bare document does not begin with any directives or marker lines. Such documents are very "clean" as they contain nothing other than the content. In this case, the first non-comment line may not start with a "% " first character.

Document nodes are indented as if they have a parent indented at -1 spaces. Since a node must be more indented than its parent node, this allows the document's node to be indented at zero or more spaces.

[207] l-bare-document ::=
s-l+block-node(-1,BLOCK-IN) /* Excludingc-forbidden content */

9.1.4. Explicit Documents

An explicit document begins with an explicit directives end marker line but no directives. Since the existence of the document is indicated by this marker, the document itself may be completely empty.

9.1.5. Directives Documents

[209] l-directive-document ::=
l-directive+l-explicit-document

9.2. Streams

[211] l-yaml-stream ::=
l-document-prefix*l-any-document? ( (l-document-suffix+l-document-prefix*l-any-document? ) |c-byte-order-mark |l-comment |l-explicit-document )*

A sequence of bytes is a well-formed stream if, taken as a whole, it complies with the above l-yaml-stream production.

A YAML schema is a combination of a set of tags and a mechanism for resolving non-specific tags.

10.1. Failsafe Schema

The failsafe schema is guaranteed to work with any YAML document. It is therefore the recommended schema for generic YAML tools. A YAML processor should therefore support this schema, at least as an option.

10.1.1.1. Generic Mapping

Definition

Represents an associative container, where each key is unique in the association and mapped to exactly one value. YAML places no restrictions on the type of keys; in particular, they are not restricted to being scalars. Example bindings to native types include Perl's hash, Python's dictionary and Java's Hashtable.

10.1.1.2. Generic Sequence

Definition

10.1.1.3. Generic String

Definition

Canonical Form:

The obvious.

10.1.2. Tag Resolution

All nodes with the "!" non-specific tag are resolved, by the standard convention, to " tag:yaml.org,2002:seq", " tag:yaml.org,2002:map" or " tag:yaml.org,2002:str", according to their kind.

All nodes with the "?" non-specific tag are left unresolved. This constrains the application to deal with a partial representation.

10.2. JSON Schema

The JSON schema is the lowest common denominator of most modern computer languages and allows parsing JSON files. A YAML processor should therefore support this schema, at least as an option. It is also strongly recommended that other schemas should be based on it.

10.2.1.1. Null

Definition

Represents the lack of a value. This is typically bound to a native null-like value (e.g., undef in Perl, None in Python). Note that a null is different from an empty string. Also, a mapping entry with some key and a null value is valid and different from not having that key in the mapping.

10.2.1.2. Boolean

Definition

Canonical Form

Either true or false.

10.2.1.3. Integer

Definition

Some languages (such as Perl) provide only a "number" type that allows for both integer and floating-point values. A YAML processor may use such a type for integers as long as they round-trip properly.

In some languages (such as C), an integer may overflow the native type's storage capability. A YAML processor may reject such a value as an error, truncate it with a warning or find some other manner to round-trip it. In general, integers representable using 32 binary digits should safely round-trip through most systems.

Canonical Form

Decimal integer notation, with a leading "-" character for negative values, matching the regular expression 0 | -? [1-9] [0-9]*

10.2.1.4. Floating Point

Definition

Represents an approximation to real numbers, including three special values (positive and negative infinity and "not a number").

Some languages (such as Perl) provide only a "number" type that allows for both integer and floating-point values. A YAML processor may use such a type for floating-point numbers, as long as they round-trip properly.

Not all floating-point values can be stored exactly in any given native type. Hence a float value may change by "a small amount" when round-tripped. The supported range and accuracy depends on the implementation, though 32 bit IEEE floats should be safe. Since YAML does not specify a particular accuracy, using floating-point mapping keys requires great care and is not recommended.

Canonical Form

Either 0, .inf, -.inf, .nan or scientific notation matching the regular expression
-? [1-9] ( \. [0-9]* [1-9] )? ( e [-+] [1-9] [0-9]* )?.

10.2.2. Tag Resolution

All nodes with the "!" non-specific tag are resolved, by the standard convention, to " tag:yaml.org,2002:seq", " tag:yaml.org,2002:map" or " tag:yaml.org,2002:str", according to their kind.

Collections with the "?" non-specific tag (that is, untagged collections) are resolved to " tag:yaml.org,2002:seq" or " tag:yaml.org,2002:map" according to their kind.

Scalars with the "?" non-specific tag (that is, plain scalars) are matched with a list of regular expressions (first match wins, e.g. 0 is resolved as!!int). In principle, JSON files should not contain any scalars that do not match at least one of these. Hence the YAML processor should consider them to be an error.

Regular expression

Resolved to tag

Note: The regular expression for float does not exactly match the one in the JSON specification, where at least one digit is required after the dot:( \. [0-9]+ ). The YAML 1.2 specification intended to match JSON behavior, but this cannot be addressed in the 1.2.2 specification.

Example 10.8 JSON Tag Resolution

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 ]

10.3. Core Schema

The Core schema is an extension of the JSON schema, allowing for more human-readable presentation of the same types. This is the recommended default schema that YAML processor should use unless instructed otherwise. It is also strongly recommended that other schemas should be based on it.

10.3.2. Tag Resolution

All nodes with the "!" non-specific tag are resolved, by the standard convention, to " tag:yaml.org,2002:seq", " tag:yaml.org,2002:map" or " tag:yaml.org,2002:str", according to their kind.

Collections with the "?" non-specific tag (that is, untagged collections) are resolved to " tag:yaml.org,2002:seq" or " tag:yaml.org,2002:map" according to their kind.

Scalars with the "?" non-specific tag (that is, plain scalars) are matched with an extended list of regular expressions. However, in this case, if none of the regular expressions matches, the scalar is resolved to tag:yaml.org,2002:str (that is, considered to be a string).

Regular expression

Resolved to tag

Example 10.9 Core Tag Resolution

A null: null
Also a null: # Empty
Not a null: ""
Booleans: [ true, True, false, FALSE ]
Integers: [ 0, 0o7, 0x3A, -19 ]
Floats: [
  0., -0.0, .5, +12e03, -2E+05 ]
Also floats: [
  .inf, -.Inf, +.INF, .NAN ]

10.4. Other Schemas

None of the above recommended schemas preclude the use of arbitrary explicit tags. Hence YAML processors for a particular programming language typically provide some form of local tags that map directly to the language's native data structures (e.g., !ruby/object:Set).

It is strongly recommended that such schemas be based on the core schema defined above.

# data[].attributes.attachment_link.title
YAML Ain't Markup Language (YAML™) revision 1.2.2

# data[].attributes.attachment_link.description
Copyright presently by YAML Language Development Team Copyright 2001-2009 by Oren Ben-Kiki, Clark Evans, Ingy döt Net This document may be freely copied, provided it is not modified. Status of this Document This is the YAML specification v1.2.2. It defines the YAML 1.2 data language. There are no normative changes from the YAML specification v1.2.

# data[].attributes.body
Es bestand ein Bedarf an Server-zu-Client-Kommunikation in Echtzeit, was zur Entwicklung von JSON führte. Das JSON-Format wurde erstmals im März 2001 von Douglas Crockford spezifiziert. JSON basierte auf dem Standard ECMA-262 3rd Edition – Dezember 1999, der eine Teilmenge von JavaScript ist.

Die erste Ausgabe des JSON-Standards ECMA-404 wurde im Oktober 2013 von Ecma International veröffentlicht. RFC 7159 wurde 2014 zur Hauptreferenz für die Verwendung von JSON im Internet. Im November 2017 wurde ISO/IEC 21778:2017 als internationaler Standard veröffentlicht. RFC 8259 wurde am 13. Dezember 2017 von The Internet Engineering Task Force veröffentlicht und ist die aktuelle Version des Internet-Standards STD 90.

# data[].attributes.body
JSON (JavaScript Object Notation) und YAML (YAML Ain't Markup Language) sind beide Formate zur Darstellung von strukturierten Daten, aber sie haben einige Unterschiede in Bezug auf Syntax, Lesbarkeit und Verwendungszweck. Hier ist ein Vergleich zwischen JSON und YAML:

1. Syntax:

JSON: JSON verwendet eine strikte Syntax mit geschweiften Klammern {} für Objekte und eckigen Klammern [] für Listen. Daten werden durch Doppelpunkte : getrennt.

YAML: YAML verwendet eine weniger strenge Syntax und verlässt sich auf Einrückungen (Whitespaces) zur Definition der Hierarchie. Objekte und Listen werden durch Doppelpunkte : und Bindestriche - angegeben, und Einrückungen bestimmen die Verschachtelung.

2. Lesbarkeit:

YAML: YAML wird oft als menschenlesbarer empfunden, da es weniger Symbole und Klammern verwendet und sich stark auf die Einrückung verlässt. Dies erleichtert die Lesbarkeit und das Schreiben von Konfigurationsdateien.

JSON: JSON ist zwar nicht so menschenleserlich wie YAML, aber es ist immer noch recht verständlich. JSON wird häufig in der Webentwicklung und für den Datenaustausch verwendet.

3. Erweiterbarkeit:

JSON: JSON ist eher starr und bietet weniger Möglichkeiten zur Kommentierung und Erweiterung von Daten. Es ist hauptsächlich für den Datenaustausch konzipiert.

YAML: YAML ist flexibler und erlaubt Kommentare und einfache Erweiterungen. Dies macht es gut geeignet für Konfigurationsdateien und Textdateien, die sowohl von Menschen als auch von Maschinen gelesen werden.

4. Datentypen:

JSON: JSON unterstützt eine begrenzte Anzahl von Datentypen, darunter Objekte, Listen, Zeichenketten, Zahlen, boolesche Werte und null.

YAML: YAML unterstützt eine breitere Palette von Datentypen, einschließlich Datum, Zeit, Binärdaten und benutzerdefinierte Datentypen.

5. Anwendungsgebiete:

JSON: JSON wird häufig in der Webentwicklung, APIs und dem Datenaustausch verwendet. Es ist gut geeignet für strukturierte Daten und Maschinen-zu-Maschinen-Kommunikation.

YAML: YAML wird häufig für Konfigurationsdateien in Softwareanwendungen, insbesondere in DevOps- und Konfigurationsmanagement-Szenarien, verwendet. Es ist gut geeignet für menschenlesbare Konfigurationen.

# data[].attributes.body
JSON und XML beschreiben die Struktur eines Datensatzes. Dieser kann weitere Datensätze enthalten, dadurch sind beliebig tief verschachtelte Strukturen möglich. In XML sind die Knoten benannt, während die Knoten in JSON unbenannt sind. Syntax von JSON sind viel einfacher gestaltet und produziert geringeren Overhead. In XML können Zeichenketten als Attribut eines Elements oder als eigenständiges Element stehen. Diese Entscheidung gibt es bei JSON nicht.

# data[].attributes.body
YAML (Yet Another Markup Language oder YAML Ain't Markup Language) ist ein menschenlesbares Datenformat, das auf einfache Lesbarkeit für Menschen ausgerichtet ist. Es verwendet minimale Syntax und Einrückungen, um hierarchische Datenstrukturen darzustellen. YAML kann sowohl einfache Daten als auch komplexe Datenstrukturen wie Listen und verschachtelte Maps repräsentieren. Es ist plattformunabhängig, ermöglicht Kommentare und wird häufig für Konfigurationsdateien in der Softwareentwicklung und die Datenübertragung zwischen Systemen verwendet.

# data[].attributes.body
XML wurde von der XML Working Group (bekannt auch als SGML Editorial Review Board) entwickelt, die unter der Schirmherrschaft von World Wide Web Consortium (W3C) in 1996 gegründet wurde. Die Grundidee und die Ziele von XML waren dabei, dass es Dokumente gibt, die alle in ihrem Aufbau bestimmten Grundmustern folgen.

# data[].attributes.body
CSV steht für "Comma-Separated Values".

Textbasiertes Dateiformat für tabellarische Daten.

Trennung von Spalten durch Kommas, Semikolons oder Tabulatoren.

Häufig eine Headerzeile mit Spaltennamen.

Einfache Struktur ohne Formatierungsanweisungen.

Flexibel für Datenimporte und -exporte.

Codierung beachten (z.B. UTF-8).

Häufige Verwendung in Tabellenkalkulationen und Datenbanken.

Datenintegrität und Sonderzeichen beachten.

# data[].attributes.body
JSON (JavaScript Object Notation) ist ein Datenformat, das strukturierte Daten in Schlüssel-Wert-Paaren darstellt. Es ermöglicht die Speicherung und Übertragung von Informationen in einer leicht lesbaren und plattformunabhängigen Form. JSON-Daten bestehen aus Objekten, die in geschweiften Klammern {} eingeschlossen sind und Schlüssel-Wert-Paare enthalten. Diese Schlüssel können Zeichenketten sein, und die Werte können Zeichenketten, Zahlen, boolesche Werte, null oder verschachtelte JSON-Objekte und Arrays sein. JSON wird häufig in Webanwendungen für die Datenkommunikation verwendet und eignet sich auch für die Speicherung von Konfigurationsdaten oder als internes Datenformat in NoSQL-Datenbanken.

# data[].attributes.body
CSV-Dateien können mit den Anwendungen, die diese Dateien öffnen können, in verschiedene Dateiformate konvertiert werden. Beispielsweise kann Microsoft Excel Daten aus dem CSV-Dateiformat importieren und in XLS, XLSX, PDF, TXT speichern.

# data[].attributes.body
XML kann auf verschiedene Arten eingesetzt werden. Am Beginn jedes Einsatzes von XML steht aber die Erstellung einer XML-Datei. Hierbei handelt es um ein Textdokument mit der Endung .xml, das in jedem beliebigen Texteditor erstellt werden kann. Damit ein gültiges Dokument entsteht, muss man sich an die Syntax der Sprache halten. Solche Dokumente können etwa immer dann genutzt werden, wenn HTML an seine Grenzen stößt. Oft ist dies beispielsweise bei Sitemap von Websites der Fall. Hierbei wird eine sitemap.xml -Datei erstellt.

Um die XML-Dokumente einzulesen, wird ein sogenannter Parser benötigt. Dieser stellt eine Programmierschnittstelle bereit, mittels der verschiedene Anwendungen auf das XML-Dokument zugreifen können. Dieser Zugriff kann auf verschiedene Arten erfolgen:

DOM: Das XML-Dokument wird als Baumstruktur repräsentiert und kann auf diese Weise gelesen werden. Auch das Verändern der Baumstruktur sowie das Schreiben in die Baumstruktur sind erlaubt.

Pull-API: Die Daten aus dem XML-Dokument werden sequenziell und meistens ereignisbasiert verarbeitet.

SAX: Auch hier wird das XML-Dokument als sequenzieller Strom von Daten behandelt.

Webbrowser haben solch einen Parser in den meisten Fällen bereits eingebaut, sodass das Lesen von XML-Dokumenten für die Standardbrowser kein Problem darstellt.

# data[].attributes.body
Beschreibung
- Name: Comma-Seperated-Values
- Darstellung von Daten in einer Datei
- Anwendung: Austausch von Daten zwischen verschiedenen Anwendungen

Aufbau
- Erste Zeile beschreibt die Struktur der Felder
- Jede Zeile wird mit einem Zeilenumbruch abgeschlossen
- Felder werden mit Komma separiert
__________
Jasin Manachadshijev

# data[].attributes.body
XML = Extensive Markup Language
XML dient zur Darstellung und Veranschaulichung von Daten in einem formatiertem Textformat
Sie wurde ursprünglich entwickelt um Daten Plattformabhängig und Programmiersprachenabhängig zu übertragen und darzustellen.
XML basieren immer auf dem selben Schema
Alle Informationen werden in Tags übergeben
und mit größer / kleiner Zeichen umschlossen

<?xml version="1.0" encoding="UTF-8"?>
<Kundenliste>
<Kunde>
<Kundennummer>12345</Kundennummer>
<Name>Hans Müller</Name>
<Adresse>
<Strasse>Musterstraße 1</Strasse>
<Stadt>Musterstadt</Stadt>
<PLZ>12345</PLZ>
<Land>Deutschland</Land>
</Adresse>
</Kunde>
</Kundenliste>

XQuery ist eine Query-language mit welcher man einfach auf XML - Elemente zugreifen kann
(XQuery is nice)

# data[].attributes.body
Fakten über den Ursprung und die Geschichte des CSV-Dateiformats:

1972 - Der Compiler IBM Fortran (Level H erweitert) unterstützte sie unter OS/360

1978 - Listengesteuerte Eingabe/Ausgabe wurde von FORTRAN 77 unterstützt, das Kommas und Leerzeichen als Trennzeichen verwendete

2005 - CSV wurde mit RFC4180 als MIME-Inhaltstyp standardisiert.

2013 - Die Mängel von RFC4180 wurden durch eine W3C-Empfehlung behoben

2015 - W3C hat die ersten Empfehlungen für CSV-Metadatenstandards erstellt, die im Dezember 2015 als Empfehlung begannen

# data[].attributes.body
XML (Extensible Markup Language) ist eine häufig verwendete Datenformatierungssprache, die zur Strukturierung und Speicherung von Daten dient. In Python gibt es verschiedene Möglichkeiten, XML-Dateien zu verarbeiten

# data[].attributes.body
Die YAML-Datei besteht aus den folgenden Datentypen

Skalare: Skalare sind Werte wie Strings, Integers, Booleans usw.

Sequenzen: Sequenzen sind Listen, bei denen jedes Element mit einem Bindestrich (-) beginnt. Listen können auch verschachtelt werden.

Mappings: Mapping gibt die Möglichkeit, Schlüssel mit Werten aufzulisten.

# data[].attributes.body
YAML wurde zuerst als “Yet Another Markup Language” bezeichnet, um seinen Zweck als Auszeichnungssprache anzuzeigen. Es wurde später als “YAML Aint Markup Language” umbenannt, um seinen Zweck als datenorientiert anzuzeigen.
Es wurde  2001 vorgeschlagen und von Clark Evans, Ingy döt Net und Oren Ben-Kiki entwickelt.

# data[].attributes.body
XML (eXtensible Markup Language) ist eine textbasierte Auszeichnungssprache zur Darstellung strukturierter Daten. Es ermöglicht die Erstellung hierarchischer Datenstrukturen durch Verwendung von Tags und ist plattformunabhängig. XML-Dokumente bestehen aus Elementen, die hierarchisch verschachtelt sein können, und sie können Attribute enthalten. XML kann für verschiedene Zwecke angepasst werden und wird in der Datenübertragung, zur Speicherung von Konfigurationsdaten, in Datenbanken und Webdiensten eingesetzt.

# data[].attributes.body
JSON (JavaScript Object Notation) ist ein offenes Standarddateiformat zum Teilen von Daten, das menschenlesbaren Text zum Speichern und Übertragen von Daten verwendet.
Wird auch für den Austausch zwischen Clients und Webservern verwendet.
JSON erfordert weniger Formatierung und ist eine gute Alternative für XML. JSON ist von JavaScript abgeleitet, aber ein sprachunabhängiges Datenformat.
Das Generieren und Parsen von JSON wird von vielen modernen Programmiersprachen unterstützt.

# data[].attributes.body
JSON ist in der Webentwicklung ein wichtiges Datenformat, insbesondere beim Austausch von Daten mittels Schnittstellenstandards wie RESTful API. Im Vergleich zu anderen Möglichkeiten für die Darstellung strukturierter Daten, etwa XML, ist JSON einfach zu erlernen, intuitiv in der Anwendung und performant im Prozess.

# data[].attributes.body
CSV, eine Abkürzung für „Comma Separated Values“, ist ein gebräuchliches Dateiformat, das zum Speichern von Daten in Tabellenform verwendet wird. Es ist ein einfaches und leicht verständliches Format, das in der Regel von Texteditoren geöffnet und bearbeitet werden kann. Die meisten Anwendungen, die Daten in tabellarischer Form speichern, unterstützen dieses Format. In diesem Artikel werden wir uns näher mit dem CSV-Dateiformat befassen und einige der häufigsten Fragen beantworten.

# data[].attributes.body
JSON (JavaScript Object Notation) ist ein häufig verwendetes Format für den Datenaustausch zwischen verschiedenen Anwendungen. In Python kannst du JSON-Dateien mithilfe der integrierten json-Bibliothek verarbeiten

# data[].attributes.body
Mit dem CSV-Datenformat lassen sich in erster Linie einfach strukturierte Daten speichern, weiterverarbeiten und austauschen. CSV-Dateien eignen sich also gut, um Daten wir Verkaufszahlen, Mitarbeiter, usw. zu speichern und zu verwerten

# data[].attributes.body
YAML ist ein menschenlesbares Datenformat, das häufig für Konfigurationsdateien und den Datenaustausch zwischen verschiedenen Programmiersprachen verwendet wird. Es zeichnet sich durch seine Einfachheit und Lesbarkeit aus und verwendet Einrückungen sowie eine minimale Syntax.

# data[].attributes.body
Die Leistungsfähigkeit von XML macht es zu einer universellen Sprache für die Datenkommunikation über das Netzwerk, indem Datentransport und Plattformwechsel vereinfacht werden.
HTML dient der Datendarstellung über das Internet, während XML dem Datenaustausch dient. Die in XML verwendeten Markup-Tag-Paare definieren die Schlüsselelemente der Struktur, die von Leseanwendungen verwendet werden sollen.

# data[].attributes.body
JavaScript Object Notation
Datenaustauschformat
Textformat, welches komplett unabhängig von Programmiersprachen ist
basiert auf zwei Strukturen:
- Name/Wert Paare
- geordnete Liste von mehreres Werten
Es gibt:
- Objekte
- Arrays
- Werte
- Zeichenketten

# data[].attributes.body
Eine CSV-Datei stellt das Original einer Tabelle oder Datenbank als Text dar und trennt die Inhalte der einzelnen Felder und Zellen durch Zeichen, üblicherweise Komma oder Semikolon
"Redaktion COMPUTER BILD"

# data[].attributes.body
XML ist ähnlich wie HTML eine Programmiersprache zur Strukturierung und Darstellung von Daten in einem formatierten Textformat.

# data[].attributes.body
JSON-Daten werden in Schlüssel/Wert-Paaren geschrieben, kann aber auch als geordnete Liste von Werten (array, list, vector, sequence) realisiert werden.
JSON-Objekte können auch verschachtelt werden, um die Struktur der Daten darzustellen.

JSON bietet im Vergleich zu XML-Dateiformaten:
- eine klare und leichter lesbare Ansicht der Daten
- reduziert den Overhead der Datenübertragung über das Internet
- Moderne Programmiersprachen bieten integrierte Parser

# data[].attributes.body
Eine CSV-Datei (durch Kommas getrennte Werte) ist ein spezieller Dateityp, den Sie in Excel erstellen oder bearbeiten können. Statt Informationen in Spalten zu speichern, werden Informationen in CSV-Dateien durch Kommas getrennt.

# data[].attributes.body
JSON unterstützt die Datentypen bool, float, int, string, array und object.

Meistens ist das oberste Element ein Array oder ein Object.

# data[].attributes.body
textbasiertes Datenformat
ähnlich wie JSON
können mit Editor bearbeitet werden
besteht aus Tags <>
Tags sind definierbar

# data[].attributes.body
xml steht für Extensible Markup Language, also eine „erweiterbare Auszeichnungssprache“. In diesem Format werden Daten so gespeichert, dass sie einerseits für Maschinen, andererseits aber auch für Menschen lesbar sind. Eine .xml-Datei ist ein textbasiertes Datenformat, das mit den meisten Texteditoren kompatibel ist.

# data[].attributes.headline
Wie verbindet man eine CSV Datei mit Python?

# data[].attributes.subject
Wie verbindet man eine CSV Datei mit Python?

# data[].attributes.body
Um eine .csv Datei mit Python zu verbinden, muss man die bereits in Python eingebaute CSV-Bibliothek importieren. Dann muss man nur mehr eine Verbindung mit der open() Funktion herstellen. Viele Entwickler installieren zusätzlich das Panda Plugin, um die Arbeit mit CSV-Datein zu vereinfachen.

# data[].attributes.body
YAML (YAML Ain't Markup Language) ist eine menschenfreundliche Daten-Serialisierungs-Sprache, die oft für Konfigurationsdateien und Datenstrukturen verwendet wird. In Python kannst du YAML-Dateien mithilfe einer Bibliothek namens PyYAML verarbeiten.