YAML文件规范
yml命名规则 -回复
yml命名规则-回复YAML命名规则，以中括号内的内容为主题，写一篇1500-2000字文章，一步一步回答YAML（又名“YAML Ain't Markup Language”）是一种常用于配置文件和数据序列化的标记语言。
它以易读的文本格式来表示数据，具有良好的可读性和易用性。
本文将逐步介绍YAML的命名规则及相关的使用注意事项。
第一步，了解YAML的基本结构和概念。
YAML的基本结构由键值对组成，使用冒号分隔键和值。
键-值对可以包含在一个对象中，对象由大括号括起来，多个对象可以组成一个文档，文档是用连续的三个短横线（）分隔的对象集合。
第二步，理解YAML中的标量类型。
YAML支持多种标量类型，包括字符串、整数、浮点数、布尔值和空值。
字符串可以使用单引号或双引号来表示，若字符串中包含特殊字符可以使用转义字符进行处理。
整数和浮点数可以直接表示，布尔值可以用true和false表示，空值可以用null表示。
第三步，学习YAML中的复合类型。
除了标量类型，YAML还支持复合类型，如数组和字典。
数组由一个或多个元素组成，元素之间使用“- ”做前缀表示。
字典由多个键值对组成，键值对之间使用冒号分隔。
第四步，了解YAML中的注释和折叠。
在YAML中，可以使用井号（#）来进行注释，注释后面的文本将被忽略。
此外，YAML还支持折叠，可通过大于号（>）或连字符（）来指定文本的折叠方式。
大于号将文本折叠为一行，连字符将文本折叠为多行。
第五步，掌握YAML中的引用和锚点。
在YAML中，可以使用“&”来给值设定一个锚点，然后使用“*”来引用该锚点。
引用可以帮助简化重复的值或结构，提高代码的可维护性。
第六步，进一步学习YAML的高级特性。
YAML还支持包含和继承，通过使用“<”和“*”来实现。
包含可以将其他YAML文件的内容插入到当前文件中，继承可以重用其他YAML文件中的键-值对。
第七步，了解YAML的规则和注意事项。
yaml格式介绍 -回复
yaml格式介绍-回复什么是YAML格式？YAML格式（YAML，Yet Another Markup Language的缩写）是一种用于表示数据序列化的文本格式。
它的设计宗旨是易读性高、简洁明了、功能完备，适用于各种编程语言的数据存储和传输。
YAML格式使用空格进行缩进，并采用可读性强的格式，使得开发者可以轻松地解析和生成YAML格式的数据。
YAML格式的特点1. 可读性强：YAML格式以易读的方式来存储和传输数据，其语法结构简洁明了。
使用空格进行缩进和换行，使得数据具有良好的结构和可读性，方便开发者阅读和编辑。
2. 易于解析：相对于其他标记语言（如XML和JSON），YAML格式的解析相对简单。
它的语法结构简洁，不需要使用繁杂的标记符号，开发者可以快速地解析和处理YAML格式的数据。
3. 支持多种数据类型：YAML格式支持多种常见的数据类型，包括字符串、整数、浮点数、布尔值、日期/时间和空值等。
开发者可以按照需要将各种类型的数据存储在YAML格式文件中。
4. 易于扩展：YAML格式可以通过引入标记语言和自定义数据类型来扩展其功能。
开发者可以根据自己的需求定义新的标记语言和数据类型，增加YAML格式的灵活性和可扩展性。
YAML格式的语法规则YAML格式的语法规则有以下几点：1. 缩进：YAML格式使用空格进行缩进，每级缩进为两个空格。
缩进用于表示嵌套关系，多个相同级别的元素具有相同的缩进。
2. 键值对：使用冒号（:）来表示键值对的关系。
冒号后面的值可以使用空格进行缩进，也可以直接写在冒号后面。
3. 列表：使用连字符（-）表示列表。
连字符后面的值可以使用空格进行缩进，也可以直接写在连字符后面。
多个连字符表示多个元素，它们具有相同的缩进。
4. 注释：使用井号（#）表示注释。
井号后面的内容将被忽略，不参与数据的解析和处理。
下面是一个简单的示例，展示了YAML格式的语法结构：yaml# 这是一个YAML格式的示例name: John Smithage: 30address:street: 123 Main Streetcity: New Yorkcountry: USAinterests:- hiking- reading在这个示例中，name、age和address是键值对，address的值是一个嵌套的键值对。
Yaml--配置文件
Yaml--配置⽂件1、Yaml 介绍及安装（1）yaml介绍Yaml 是⼀种所有编程语⾔可⽤的友好的数据序列化标准。
语法和其他⾼阶语⾔类似，并且可以简单表达字典、列表和其他基本数据类型的形态。
语法规则如下：1. ⼤⼩写敏感。
2. 使⽤缩进表⽰层级关系。
3. 使⽤空格键缩进，⽽⾮Tab键缩进4. 缩进的空格数⽬不重要，只要相同层级的元素左侧对齐即可。
5. ⽂件中的字符串不需要使⽤引号标注，但若字符串包含有特殊字符则需⽤引号标注；（2）Yaml 安装$ pip3 install PyYaml（3）Yaml 快速体验 字典{"name": "test_yaml", "result", "success"}写成Yaml的形式，并输出结果结构通过空格缩进来展⽰。
列表⾥的项⽤"-"来代表，字典⾥的键值对⽤":"分隔.⽰例函数：data.yamlname: "test_yaml"result: "success"demo.pyimport yamlwith open("./data.yaml",'r') as f:data = yaml.safe_load(f)print(data)运⾏结果： {'name': 'test_yaml', 'result': 'success'}2、Yaml 字典和列表介绍（1）字典字典⾥的键值对⽤":"分隔.⽰例： {"name": "test_yaml", "result", "success"}name: "test_yaml"age: "success"总结：字典直接写key和value，每⼀个键值对占⼀⾏。
yaml 文件格式 shell解析
yaml 文件格式shell解析全文共四篇示例，供读者参考第一篇示例：YAML 是一种易读性高、使用方便的数据序列化格式，常见于配置文件和数据交换中。
在工作中我们经常会遇到需要解析YAML 文件的情况，这时候就可以使用shell 脚本来进行解析。
本文将介绍如何通过shell 脚本来解析YAML 文件，并举例说明其基本用法和注意事项。
一、YAML 文件格式YAML 是一种基于缩进的数据格式，使用空格来表示层次关系。
它使用两种基本结构：键值对和列表。
在YAML 文件中，键值对使用冒号“:” 分隔，键值对之间使用换行符分隔；列表则使用中括号“[]” 表示，其中每个元素用逗号分隔。
下面是一个简单的YAML 文件示例：```yamlname: Aliceage: 25skills: [Java, Python, Shell]```在shell 脚本中，可以通过解析YAML 文件来获取其中的数据，从而实现对配置文件的读取和处理。
二、shell 解析YAML 文件在shell 脚本中，可以使用第三方工具来解析YAML 文件，常用的工具有yq、jq、awk 等。
下面以yq 工具为例，介绍如何使用shell 脚本来解析YAML 文件。
1. 安装yq 工具yq 是一个命令行工具，用于在shell 脚本中解析YAML 文件。
可以通过以下命令来安装yq：```shellsudo apt-get install yq```接下来，我们通过一个例子来说明如何使用yq 工具来解析YAML 文件。
假设我们有一个名为config.yaml 的YAML 文件，内容如下：我们可以通过以下shell 脚本来解析config.yaml 文件：```shell#!/bin/bashname=(yq r config.yaml name)age=(yq r config.yaml age)skills=(yq r config.yaml skills)执行以上脚本，输出如下：三、注意事项1. 缩进问题：YAML 文件的缩进非常重要，要保持一致性，否则会导致解析错误。
yml文件编写格式
yml文件编写格式YML（YAML）文件是一种用于配置数据的格式，它使用缩进和特定的标记来表示数据结构。
下面我将从多个角度全面地解释YML文件的编写格式。
1. 文件扩展名，YML文件通常使用`.yml`或`.yaml`作为文件扩展名。
2. 缩进，YML文件使用空格进行缩进，而不是制表符。
缩进的数量和空格数可以自由选择，但是在一个文件中必须保持一致。
常见的缩进习惯是使用两个空格或四个空格。
3. 键值对，YML文件由键值对组成，键和值之间使用冒号(`:`)进行分隔。
键值对可以位于同一行，也可以使用换行符进行分隔。
4. 列表，YML文件中的列表使用短横线(`-`)表示，每个列表项占一行。
列表项可以是简单的值，也可以是嵌套的键值对。
5. 注释，YML文件支持使用井号(`#`)进行注释。
井号后面的内容将被视为注释，不会被解析。
6. 引用，在YML文件中，可以使用`&`符号进行引用，用``符号进行引用的值的替代。
这在避免重复定义相同值时非常有用。
7. 字符串，YML文件中的字符串可以使用单引号或双引号进行包裹。
使用单引号包裹的字符串保持原样，使用双引号包裹的字符串支持转义字符和变量替换。
8. 多行字符串，YML文件中的字符串可以跨多行，可以使用`|`符号进行保留换行符的多行字符串，也可以使用`>`符号进行折叠换行符的多行字符串。
9. 特殊字符，在YML文件中，某些特殊字符需要进行转义，例如冒号、短横线等。
可以使用反斜杠(`\`)进行转义。
10. 嵌套结构，YML文件支持多层嵌套的数据结构，可以使用缩进来表示嵌套关系。
总结起来，YML文件的编写格式包括文件扩展名、缩进、键值对、列表、注释、引用、字符串、多行字符串、特殊字符和嵌套结构等。
通过合理使用这些格式规则，可以编写出清晰、易读、易维护的YML配置文件。
yml 格式 语法
YAML（YAML Ain't Markup Language）是一种人类可读的数据序列化格式，通常用于配置文件和数据交换。
YAML以缩进和换行来表示数据结构，具有清晰简洁的语法，易于阅读和编写。
以下是一些常见的YAML语法规则：1. 缩进：YAML使用缩进来表示数据结构，通常使用空格来进行缩进。
缩进的空格数目没有硬性规定，但在一个文件中必须保持一致。
2. 键值对：使用冒号（:）来表示键值对。
键值对的键和值之间需要用空格隔开。
key: value3. 列表：使用连字符（-）来表示列表项。
列表项可以包含键值对或者纯值。
- item1- item2- key1: value1key2: value24. 对象：YAML中的对象可以包含键值对，使用缩进表示嵌套关系。
object1:key1: value1key2: value2object2:key3: value35. 注释：使用井号（#）来表示注释，井号后面的内容将被视为注释，不参与解析。
# This is a commentkey: value # This is another comment6. 字符串：字符串可以使用单引号或双引号括起来，也可以省略引号。
如果字符串中包含特殊字符，最好使用引号括起来。
string1: 'This is a string'string2: "This is another string"string3: This is a string without quotesstring4: "This string contains a special character: !"这些是YAML的一些基本语法规则，YAML还支持更复杂的数据结构、引用、多行字符串等特性。
使用这些语法规则，你可以编写结构清晰、易于理解的配置文件和数据文件。
yaml 格式介绍 -回复
yaml 格式介绍-回复什么是YAML 格式？YAML（Yet Another Markup Language）是一种人类可读写的、与编程语言无关的数据序列化格式。
它最初在2001年由Clark Evans创建，并得到了Sam Ruby和Oren Ben-Kiki的支持。
YAML具有结构清晰、简洁明了、易于实现和解析的特点，广泛应用于配置文件、数据交换和存储等领域。
YAML的语法规则：1. 规定了一些基本的标识符，例如“-”表示列表项、冒号“:”表示键值对等。
2. 使用缩进来表示嵌套关系，一般使用两个空格或者一个制表符作为缩进单位。
3. 支持多种数据结构，如列表、字典、布尔值、整数、浮点数、字符串等。
4. 支持提供注释，以"#" 开头，可用于解释数据的含义。
以下是一个简单的YAML 示例，展示了基本的语法与数据结构：yaml# 一个示例的YAML 文件# 资料name: John Doeage: 30occupation: Software Developer# 列表hobbies:- Reading- Writing- Coding# 其他信息isMarried: falsewebsite:在这个示例中，我们首先定义了一个数据项“name”，其值为“John Doe”。
接着定义了一个名为“age”的键值对，它的值是整数30。
同样地，我们用“occupation”定义了一个字符串类型的键值对。
接下来，我们定义了一个名为“hobbies”的列表，其中包含了三个字符串项。
最后，我们使用“isMarried”定义了一个布尔类型的键值对，并且使用“website”定义了一个字符串类型的数据。
YAML 的应用场景非常广泛，下面我们来介绍几个常见的应用场景。
1. 配置文件：YAML被广泛用于配置文件的编写。
由于其简洁明了的语法，易于理解和修改，使得开发人员和系统管理员更容易进行配置管理。
github workflow yaml规则
github workflow yaml规则GitHub Workflow是GitHub提供的一种持续集成和持续部署的功能，它通过配置文件（即YAML文件）定义了一系列自动化的任务和工作流程。
这个配置文件被称为workflow.yml，它具有一定的规则和参数，以确保工作流能够按照预期顺利执行。
以下是GitHub Workflow YAML规则的一些重要要点：1. name（名称）: 这是workflow的名称，用于在GitHub上显示，应该具备描述性。
例如：name: Build and Deploy。
2. on（触发条件）: 定义了工作流程应该在什么条件下被触发。
可以是一个事件类型，例如push、pull_request、schedule等，也可以是特定的分支或标签。
例如：on: push。
3. jobs（工作）: 定义了workflow中的一个或多个具体的工作任务。
每个工作任务可以有自己的名称，并包含一系列的步骤（steps）。
例如：jobs: build。
4. steps（步骤）: 定义了每个工作任务具体需要执行的步骤。
步骤可以是一系列的命令、操作或动作，例如构建代码、运行测试等。
每个步骤都是按顺序执行的。
例如：steps: - name: Build - run: make build。
5. env（环境变量）: 可选的环境变量，例如API keys或其他秘密信息。
这些变量可以在workflow的任何步骤中使用。
例如：env: API_TOKEN:${{ secrets.API_TOKEN }}。
6. runs-on（运行环境）: 指定了工作任务应该运行的操作系统或虚拟环境。
可以是Linux、Windows或macOS等。
例如：runs-on: ubuntu-latest。
7. if（条件语句）: 可选的条件语句，用于根据某些条件来决定是否执行某个步骤。
条件语句可以使用GitHub Actions提供的特定函数和语法来定义。
yaml的key的标准
yaml的key的标准
YAML是一种以数据为中心的配置文件格式，它使用键值对的方式来组织数据。
在YAML中，键的标准包括以下几个方面：
1. 键是区分大小写的，使用英文字符和数字组成，可以包含下划线和破折号。
但是，键不能以破折号开头，也不能以问号结尾。
2. 键可以使用引号包裹起来，这种情况下可以包含特殊字符和空格。
引号可以是单引号(')或双引号(")。
3. 键可以使用冒号(:)或等号(=)与值进行分隔。
4. 键值对之间使用冒号(:)或等号(=)进行分隔。
5. 键值对可以写在同一行，也可以写在多行。
如果写在多行，需要使用缩进表示嵌套关系。
6. 键值对可以嵌套使用，形成复杂的数据结构。
在YAML中，键的大小写敏感，这意味着“key”和“Key”被视为两个不同的键。
此外，YAML还具有灵活的缩进规则，允许使用空格或制表符来缩进，但需要注意同一层级的元素左侧应该对齐。
yaml中变量命名规则
yaml中变量命名规则
在使用YAML配置文件时，为了实现更好的可读性和易维护性，我们需要遵
守一些变量命名规则。
下面是一些常用的规则：
1. 小写字母和下划线：在YAML中，变量名应该使用小写字母，并且可以使
用下划线来分隔单词。
例如，"my_variable"是一个符合命名规则的变量名。
2. 避免使用特殊字符：变量名应该避免使用特殊字符，如空格、标点符号或其
他特殊符号。
这样可以确保变量名的可读性和可解析性。
3. 易于理解的名称：变量名应该选择能够清晰表达其含义的名称。
使用具有描
述性的词汇可以帮助其他人更好地理解变量的用途和作用。
4. 简洁明了：尽量使用简洁的变量名，避免过长或冗余的命名。
这样做可以提
高代码的可读性和编写效率。
5. 避免关键字：避免使用与编程语言或YAML关键字相同的名称作为变量名。
这样可以避免潜在的冲突和错误。
6. 统一命名风格：建议在整个项目中使用一致的命名风格。
无论是使用驼峰命
名法还是下划线命名法，都要保持一致性。
总之，良好的变量命名规则可以提高代码的可读性和维护性。
遵循这些规则能
够使代码更易于理解和解析，提高开发效率，并减少出错的可能性。
请在编写YAML文件时牢记这些命名规则，以确保代码的质量和可维护性。
yaml语法规则 default
文章主题：深入了解YAML语法规则YAML（YAML Ain't Markup Language）是一种人类友好的数据序列化标记语言，用来表达数据序列化以及实现各种配置文件和数据交换格式。
作为一种轻量级的数据交换格式，YAML的规则相对简单，但又有一些特殊的语法规则需要了解。
本文将深入探讨YAML的语法规则，帮助读者更加全面地了解YAML语言。
一、YAML的基本规则1. YAML使用缩进来表示层级关系，一般使用空格来进行缩进。
每一层级的缩进使用相同数量的空格，一般为2或4个空格。
2. YAML以“---”作为文件头的分隔线，在文件开始处使用这一符号进行分隔。
3. 在YAML中，使用“#”表示注释，井号后面的内容将被视为注释内容，不参与数据的解析和处理。
二、YAML的数据结构1. YAML支持多种数据结构，包括标量、序列和映射三种基本数据类型。
1）标量：表示单个的数据值，可以是字符串、数值、布尔值等。
2）序列：使用“-”来表示序列中的元素，表示一个有序集合。
3）映射：使用“键：值”的格式表示键值对，表示一个无序的键值对集合。
2. 在YAML中，数据结构之间可以互相嵌套，形成复杂的数据结构。
可以使用缩进来表示不同层级之间的关系。
三、YAML中的引号1. 在YAML中，可以使用单引号、双引号和不使用引号来表示字符串值。
1）单引号：表示纯字符串，不进行任何解析和转义。
2）双引号：表示字符串值，可以进行转义和引用其他变量。
3）不使用引号：在一些特定情况下，可以不使用引号表示字符串值。
2. 在使用引号表示字符串时，需要注意转义字符的使用，避免转义字符导致的解析错误。
四、YAML的特殊用法1. 在YAML中，可以使用特殊的标记“<<”来表示扩展其他YAML文档的内容，实现文档的继承和扩展功能。
2. 另外，YAML还支持使用“”和“*”来表示别名和引用，方便复用和引用数据内容。
五、YAML的解析规则1. 在解析YAML文件时，需要严格遵循缩进和层级关系，否则可能导致解析错误或数据结构混乱。
yaml规则
yaml规则
YAML（YAML Ain't Markup Language）是一种轻量级数据序列化语言，用于表示基于Unicode 的复杂数据。
以下是YAML 的规则：
1. YAML 文件以"" 开始，表示开始一个新的YAML 文档。
2. 缩进用空格或制表符表示，但不能混用，推荐使用空格。
3. "#" 表示注释，# 后面的内容被忽略。
4. "-" 表示列表，可以用来表示数组或序列。
5. ":" 表示键值对，键值对需要用空格分隔。
6. 大量文本可以使用'' 或'>' 来表示，'' 表示保留所有空白，'>' 表示折叠空白。
7. 分隔符"" 和">" 后面可以跟一个数字表示缩进数量，比如：'4' 或'>2'。
8. YAML 支持多行字符串、复合键、属性、继承和引用等关系，使数据结构更
加灵活。
9. YAML 是大小写敏感的，键、值中的大小写都要注意。
10. 一个YAML 文档可以包含多个数据（例如一个文档中同时包含了一个列表和一个键值对）。
YAML 的规则简单、易懂，可读性非常好。
它的应用场景非常广泛，例如配置文件、数据交换、文本文件、自定义脚本等。
yaml文件格式规范
yaml⽂件格式规范1、yaml简述YAML是⼀个类似 XML、JSON 的标记性语⾔。
YAML 强调以数据为中⼼，并不是以标识语⾔为重点。
因⽽YAML 本⾝的定义⽐较简单，号称“⼀种⼈性化的数据格式语⾔”。
2、适⽤场景2.1 脚本语⾔由于实现简单，解析成本很低，YAML特别适合在中使⽤。
列⼀下现有的语⾔实现：Ruby，Java，Perl，Python，PHP，OCaml，JavaScript，Go 。
除了Java 和 Go，其他都是脚本语⾔。
2.2序列化YAML⽐较适合做序列化。
因为它是数据类型直转的。
2.3 配置⽂件YAML做配置⽂件也不错。
写YAML要⽐写XML快得多(⽆需关注标签或引号)，并且⽐ini⽂档功能更强。
3、数据结构YAML 认为数据由以下三种结构组成：标量，序列，键值表。
标量：单个的、不可再分的值，如：数字，字符串数组：⼀组按次序排列的值，如：python中的列表键值表：键值对的集合，如：python中的字典5、语法约定⼤⼩写敏感'#'表⽰注释使⽤ Unicode 编码作为字符标准编码字符串默认不需要引号，如果字符串包含空格或者特殊字符(例如冒号)，需要加引号使⽤缩进表⽰层级关系，缩进不允许使⽤tab，只允许空格，缩进的空格数不重要，只要相同层级的元素左对齐即可6、格式规范6.1 标量integer: 12345 # 整数标准形式octal: 0o34 # ⼋进制表⽰，以0o开头hex: 0xFF # ⼗六进制表⽰，以0x开头float: 1.23e+3 # 浮点数fixed: 13.67 # 固定⼩数minmin: -.inf # 表⽰负⽆穷notNumber: .NaN # ⽆效数字null: # 空值boolean: [true, false] # 布尔值string: '12345' # 字符串date: 2015-08-23 # ⽇期datetime: 2015-08-23T02:02:00.1z # ⽇期时间iso8601: 2015-08-23t21:59:43.10-05:00 # iso8601 ⽇期格式6.2 数组使⽤“-”（横线）+单个空格表⽰单个列表项使⽤"[]"表⽰⼀组数据,⼀组数据⽤”,”隔开,”[“,”]”,逗号前后有⽆空格都可以组合表⽰。
配置文件.yml写法
配置⽂件.yml写法yaml介绍YAML 是 "YAML Ain't a Markup Language"（YAML 不是⼀种标记语⾔）的递归缩写。
在开发的这种语⾔时，YAML 的意思其实是："Yet Another Markup Language"（仍是⼀种标记语⾔）。
YAML 的语法和其他⾼级语⾔类似，并且可以简单表达清单、散列表，标量等数据形态。
它使⽤空⽩符号缩进和⼤量依赖外观的特⾊，特别适合⽤来表达或编辑数据结构、各种配置⽂件、倾印调试内容、⽂件⼤纲（例如：许多电⼦邮件标题格式和YAML⾮常接近）。
YAML 的配置⽂件后缀为 .yml，如：runoob.yml 。
编写规则1. ⼤⼩写敏感json ⾥也是⼤⼩写敏感的，这点⼆者⼀样。
2.使⽤缩进表⽰层级关系json 中使⽤ {} 的嵌套表⽰层级，⽽ yaml 使⽤缩进，后者更⽅便⼀些。
3.缩进不允许使⽤tab，只允许空格4.缩进的空格数不重要，只要相同层级的元素左对齐即可5.'#'表⽰注释json ⽂件中不允许写注释，对于很长配置⽂件全靠字⾯意思猜挺痛快的，yaml 可以写注释数据类型YAML ⽀持以下⼏种数据类型：对象：键值对的集合，⼜称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）数组：⼀组按次序排列的值，⼜称为序列（sequence） / 列表（list）纯量（scalars）：单个的、不可再分的值YAML 对象对象键值对使⽤冒号结构表⽰ key: value，冒号后⾯要加⼀个空格。
也可以使⽤ key:{key1: value1, key2: value2, ...}。
还可以使⽤缩进表⽰层级关系；key:child-key: valuechild-key2: value2转换为json{"key": {"child-key": "value","child-key2": "value2"}}YAML 数组以 - 开头的⾏表⽰构成⼀个数组：- A- B- C转化后为：['A', 'B', 'C']YAML ⽀持多维数组，可以使⽤⾏内表⽰：-- A- B- C转化后为：[['A', 'B', 'C']]⼀个相对复杂的例⼦：companies:-id: 1name: company1price: 200W-id: 2name: company2price: 500W意思是 companies 属性是⼀个数组，每⼀个数组元素⼜是由 id、name、price 三个属性构成。
yaml配置文件
yaml配置⽂件编程免不了要写配置⽂件，怎么写配置也是⼀门学问。
YAML 语⾔（发⾳ /ˈjæməl/ ）的设计⽬标，就是⽅便⼈类读写。
它实质上是⼀种通⽤的数据串⾏化格式。
YAML 是专门⽤来写配置⽂件的语⾔，⾮常简洁和强⼤，远⽐ JSON 格式⽅便。
本⽂介绍 YAML 的语法，以的实现为例。
你可以去验证下⾯的例⼦。
它的基本语法规则如下。
⼤⼩写敏感使⽤缩进表⽰层级关系缩进时不允许使⽤Tab键，只允许使⽤空格。
缩进的空格数⽬不重要，只要相同层级的元素左侧对齐即可#表⽰注释，从这个字符⼀直到⾏尾，都会被解析器忽略。
YAML ⽀持的数据结构有三种。
对象：键值对的集合，⼜称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）数组：⼀组按次序排列的值，⼜称为序列（sequence） / 列表（list）纯量（scalars）：单个的、不可再分的值以下分别介绍这三种数据结构。
⼆、对象对象的⼀组键值对，使⽤冒号结构表⽰。
animal: pets转为 JavaScript 如下。
{ animal: 'pets' }Yaml 也允许另⼀种写法，将所有键值对写成⼀个⾏内对象。
hash: { name: Steve, foo: bar }转为 JavaScript 如下。
{ hash: { name: 'Steve', foo: 'bar' } }三、数组⼀组连词线开头的⾏，构成⼀个数组。
- Cat- Dog- Goldfish转为 JavaScript 如下。
[ 'Cat', 'Dog', 'Goldfish' ]数据结构的⼦成员是⼀个数组，则可以在该项下⾯缩进⼀个空格。
-- Cat- Dog- Goldfish转为 JavaScript 如下。
[ [ 'Cat', 'Dog', 'Goldfish' ] ]数组也可以采⽤⾏内表⽰法。
yaml 文件 驼峰法
yaml 文件驼峰法
YAML文件是一种常见的配置文件格式，它具有简洁易读的特点，广泛应用于各种编程语言中。
在编写YAML文件时，有一种命名风格
叫做“驼峰法”，也被称为“骆驼拼音法”或“驼式命名法”。
“驼峰法”最初是在Java语言中普及开来的，因为Java中的命名规范就是采用此种方式。
它的命名规则是将一个单词的首字母小写，后面的单词则首字母大写，如“firstName”、“lastName”等。
在YAML文件中使用“驼峰法”命名，可以使文件更加清晰易读，方便开发者阅读与维护。
同时，也符合许多编程语言的命名规范，便于代码的编写与调用。
举个例子，在编写一个YAML文件时，我们需要定义一个用户的
信息，可以按照以下的方式使用“驼峰法”进行命名：
user:
firstNa John
lastNa Doe
age: 25
上述代码中，我们使用了“驼峰法”命名，使代码更加简洁易读。
当然，我们也可以使用其他的命名方式，如下划线命名法等，但是“驼峰法”依然是一个常见的命名方式。
总之，无论是在编写YAML文件还是编写代码中，遵循一定的命
名规范可以使代码更加规范、易读、易维护。
k8s yaml 编写指南
k8s yaml 编写指南在Kubernetes（k8s）中，YAML文件用于配置和管理资源对象。
以下是编写k8s YAML 文件的一些基本指南：1.缩进和格式：YAML文件使用缩进来表示层级关系。
不支持制表符（Tab）缩进，应使用空格缩进。
通常开头缩进两个空格，字符后缩进一个空格，如冒号、逗号等。
2.大小写敏感：YAML是大小写敏感的，因此要确保正确使用大小写。
3.文件开始：使用“---”表示YAML文件的开始，用于分隔文件间的内容。
4.注释：使用“#”来表示注释。
5.查看API版本：在编写YAML文件之前，可以使用命令kubectl api-versions来查看可用的API版本。
这将帮助你确定在YAML文件中使用的正确API版本。
6.编写资源对象的YAML文件：根据你要创建或管理的资源对象（如Pods、Services、Deployments等），编写相应的YAML文件。
确保指定正确的API版本、资源类型以及对象的属性和配置。
7.验证YAML文件：在将YAML文件应用于k8s集群之前，可以使用命令kubectlapply --dry-run -f <yaml文件>来验证YAML文件的正确性。
这将检查文件的语法和配置是否正确，但不实际创建资源对象。
8.应用YAML文件：一旦YAML文件准备就绪并通过验证，可以使用命令kubectlapply -f <yaml文件>将其应用于k8s集群。
这将根据YAML文件的配置创建或更新资源对象。
请注意，具体的YAML文件内容和结构将取决于你要管理的资源对象和所需的配置。
因此，在编写YAML文件时，建议参考k8s官方文档和相关资源对象的API文档，以确保正确配置所需的属性和参数。
yml文件编写格式
YML文件编写格式1. 什么是YML文件？YML（YAML Ain’t Markup Language）是一种人类可读的数据序列化格式，常用于配置文件和数据交换。
YML文件使用简单的缩进和冒号来表示数据结构，具有易读、易写的特点。
YML文件使用扩展名为.yml或.yaml，可以使用任何文本编辑器进行编辑。
2. YML文件的基本语法YML文件使用缩进和冒号来表示数据结构。
以下是YML文件的基本语法规则：2.1 键值对键值对使用冒号分隔，键和值之间使用空格进行缩进。
例如：key: value2.2 数组数组使用短横线-表示，每个元素占一行，并使用空格进行缩进。
例如：- item1- item2- item32.3 嵌套结构YML文件支持嵌套结构，即在一个键值对的值中可以包含另一个键值对。
嵌套结构使用缩进表示层级关系。
例如：key1:key2: value2key3: value33. YML文件的高级语法除了基本语法外，YML文件还支持一些高级语法，用于表示更复杂的数据结构。
3.1 多行字符串YML文件可以使用|表示多行字符串，保留换行符和缩进。
例如：key: |This is amulti-linestring.3.2 引用YML文件支持使用&定义引用，使用*引用已定义的引用。
例如：key1: &ref valuekey2: *ref3.3 复合键YML文件支持使用{}表示复合键，即一个键对应多个值。
例如：key:{value1: 1, value2: 2}3.4 注释YML文件支持使用#表示注释，从#开始到行末的内容将被忽略。
例如：# This is a comment.key: value4. YML文件的应用场景YML文件广泛应用于配置文件和数据交换。
以下是YML文件的一些常见应用场景：4.1 配置文件YML文件可以用于存储应用程序的配置信息，例如数据库连接信息、日志配置等。
yaml 格式介绍 -回复
yaml 格式介绍-回复YAML格式介绍在计算机编程中，数据的存储和交换是非常常见的需求。
而其中一种轻量级的数据序列化格式就是YAML（YAML Ain't Markup Language，YAML 不是一种标记语言）。
YAML格式以其简洁性、可读性和可编辑性而受到了广泛的关注和采用。
本文将逐步介绍YAML格式的基本概念、语法结构、特性以及常见应用场景等内容。
1. YAML的基本概念YAML是一种用于表示数据序列化的格式，并没有复杂的语义或特殊用途。
它的设计目标是作为一种易于阅读和编辑的数据格式。
YAML格式的数据可以被不同编程语言解析和生成，因此可以在不同的应用之间方便地传递和表示数据。
2. YAML的语法结构YAML的语法结构相对简洁，由一些基本的元素组成。
下面是一些YAML 的基本语法结构：# 2.1 键值对YAML格式中的键值对通过冒号（:）进行分隔。
键和值之间可以使用空格或制表符进行缩进。
例如：name: John Doeage: 30# 2.2 列表YAML格式还支持列表的表示，用于表示一组相关的值。
列表使用中括号（[]）表示，值之间使用逗号分隔。
例如：fruits:- apple- banana- orange# 2.3 多行文本在YAML格式中，可以使用多行来表示较长的文本内容。
多行文本可以使用竖线符号（）或折线符号（>）表示。
竖线符号表示保留换行符和缩进，而折线符号则将换行符替换为空格。
例如：description:This is a long description,it spans multiple lines.summary: >This is a long summary, itspans multiple lines as well.# 2.4 注释YAML格式也支持注释的添加，用于对数据进行解释和说明。
注释使用井号（#）进行表示，从井号开始到行尾的内容都是注释。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
YAML Ain't Markup Language(YAML™)Version1.1Working Draft2004-12-28Oren Ben-Kiki <oren@>Clark Evans <cce@>Brian Ingerson <ingy@>YAML Ain't Markup Language(YAML™) Version1.1Working Draft2004-12-28by Oren Ben-Kiki, Clark Evans, and Brian IngersonCopyright ©2001-2004 Oren Ben-Kiki,Clark Evans,Brian IngersonStatus of this DocumentThis specification is a draft reflecting consensus reached by members of the yaml-core mailing list [/lists/listinfo/yaml-core]. Any questions regarding this draft should be raised on this list. We expect all further changes will be strictly limited to wording corrections and fixing production bugs.We wish to thank implementers who have tirelessly tracked earlier versions of this specification, and our fabulous user community whose feedback has both validated and clarified our direction.AbstractYAML™ (rhymes with “camel”) is a human-friendly, cross language, Unicode based data serialization language designed around the common native data structures of agile programming languages. It is broadly useful for programming needs ranging from configuration files to Internet messaging to object persistence to data auditing. Together with the Unicode standard for characters [/], this specification provides all the information necessary to understand YAML Version 1.1 and to creating programs that process YAML information.This document may be freely copied provided it is not modified.Table of Contents1. Introduction (1)1.1. Goals (1)1.2. Prior Art (1)1.3. Relation to XML (2)1.4. Terminology (3)2. Preview (4)2.1. Collections (4)2.2. Structures (5)2.3. Scalars (6)2.4. Tags (7)2.5. Full Length Example (9)3. Processing YAML Information (10)3.1. Processes (10)3.1.1. Represent (10)3.1.2. Serialize (11)3.1.3. Present (11)3.1.4. Parse (11)3.1.5. Compose (11)3.1.6. Construct (11)3.2. Information Models (11)3.2.1. Representation Graph (12)3.2.1.1. Nodes (13)3.2.1.2. Tags (13)3.2.1.3. Nodes Comparison (14)3.2.2. Serialization Tree (14)3.2.2.1. Keys Order (15)3.2.2.2. Anchors and Aliases (15)3.2.3. Presentation Stream (15)3.2.3.1. Node Styles (16)3.2.3.2. Scalar Formats (17)3.2.3.3. Comments (17)3.2.3.4. Directives (17)3.3. Loading Failure Points (17)3.3.1. Well-Formed and Identified (18)3.3.2. Resolved (18)3.3.3. Recognized and Valid (19)3.3.4. Available (19)4. Syntax (20)4.1. Characters (20)4.1.1. Character Set (20)4.1.2. Character Encoding (21)4.1.3. Indicator Characters (21)4.1.4. Line Break Characters (25)4.1.5. Miscellaneous Characters (26)4.1.6. Escape Sequences (28)4.2. Syntax Primitives (30)4.2.1. Production Parameters (30)4.2.2. Indentation Spaces (31)4.2.3. Comments (32)4.2.4. Separation Spaces (33)4.2.5. Ignored Line Prefix (34)YAML Ain't Markup Lan-guage(YAML™) Version1.14.2.6. Line Folding (35)4.3. YAML Character Stream (36)4.3.1. Directives (37)4.3.1.1. YAML Directive (37)4.3.1.2. TAG Directive (38)4.3.1.2.1. Tag Prefixes (38)4.3.1.2.2. Tag Handles (39)4.3.2. Document Boundary Markers (40)4.3.3. Documents (41)4.3.4. Complete Stream (42)4.4. Nodes (43)4.4.1. Node Anchors (44)4.4.2. Node Tags (44)4.4.3. Node Content (47)4.4.4. Alias Nodes (49)4.4.5. Complete Nodes (49)4.4.5.1. Flow Nodes (49)4.4.5.2. Block Nodes (50)4.5. Scalar Styles (51)4.5.1. Flow Scalar Styles (51)4.5.1.1. Double Quoted (51)4.5.1.2. Single Quoted (54)4.5.1.3. Plain (57)4.5.2. Block Scalar Header (60)4.5.2.1. Block Style Indicator (61)4.5.2.2. Block Indentation Indicator (61)4.5.2.3. Block Chomping Indicator (62)4.5.3. Block Scalar Styles (64)4.5.3.1. Literal (65)4.5.3.2. Folded (66)4.6. Collection Styles (69)4.6.1. Sequence Styles (69)4.6.1.1. Flow Sequences (69)4.6.1.2. Block Sequences (70)4.6.2. Mapping Styles (72)4.6.2.1. Flow Mappings (72)4.6.2.2. Block Mappings (76)Terms Index (79)Chapter1.Introduction“YAML Ain't Markup Language” (abbreviated YAML) 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 and also a complete reference 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 mapping key:value pairs, and dashes are used to “bullet” lists.There are myriad flavors 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 data structure. While most programming languages can use YAML for data serialization, YAML excels in those languages that are fundamentally built around the three basic primitives. These include the new wave of agile languages such as Perl, Python, PHP, Ruby and Javascript.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.GoalsThe design goals for YAML are:1.YAML is easily readable by humans.2.YAML matches the native data structures of agile languages.3.YAML data is portable between programming languages.4.YAML has a consistent model to support generic tools.5.YAML supports one-pass processing.6.YAML is expressive and extensible.7.YAML is easy to implement and use.1.2.Prior ArtYAML's initial direction was set by the data serialization and markup language discussions among SML-DEV members [/smldev/]. Later on it directly incorporated experience from Brian Ingerson's Perl module Data::Denter [/doc/INGY/Data-Denter-0.13/Denter.pod]. Since then YAML has matured through ideas and support from its user community.YAML integrates and builds upon concepts described by C [/cm/cs/cbook/index.html], Java [/], Perl [/], Python [/], Ruby [/], RFC0822 [/rfc/rfc0822.txt] (MAIL), RFC1866 [/pub/ietf/html/rfc1866.txt](HTML), RFC2045 [/rfc/rfc2045.txt] (MIME), RFC2396 [/rfc/rfc2396.txt] (URI), XML [/TR/REC-xml.html], SAX [/] and SOAP [/TR/SOAP].The syntax of YAML was motivated by Internet Mail (RFC0822) and remains partially compatible with that standard.Further, borrowing from MIME (RFC2045), YAML's top-level production is a stream of independent documents; ideal for message-based distributed processing systems.YAML's indentation based scoping is similar to Python's (without the ambiguities caused by tabs). Indented blocks facilitate easy inspection of the data's structure. YAML's literal style leverages this by enabling formatted text to be cleanly mixed within an indented structure without troublesome escaping. YAML also allows the use of traditional indicator-based scoping similar to Perl's. Such flow content can be freely nested inside indented blocks.YAML's double quoted style uses familiar C-style escape sequences. This enables ASCII encoding of non-printable or 8-bit (ISO 8859-1) characters such as “\x3B”. Non-printable 16-bit Unicode and 32-bit (ISO/IEC 10646) characters are supported with escape sequences such as “\u003B” and “\U0000003B”.Motivated by HTML's end-of-line normalization, YAML's line folding employs an intuitive method of handling line breaks.A single line break is folded into a single space, while empty lines are interpreted as line break characters. This techniqueallows for paragraphs to be word-wrapped without affecting the canonical form of the content.YAML's core type system is based on the requirements of agile languages such as Perl, Python, and Ruby. YAML directly supports both collection (mapping, sequence) and scalar content. Support for common types enables programmers to use their language's native data structures for YAML manipulation, instead of requiring a special document object model (DOM).Like XML's SOAP, YAML supports serializing native graph data structures through an aliasing mechanism. Also like SOAP, YAML provides for application-defined types. This allows YAML to represent rich data structures required for modern distributed computing. YAML provides globally unique type names using a namespace mechanism inspired by Java's DNS based package naming convention and XML's URI based namespaces.YAML was designed to support incremental interfaces that includes both input pull-style and output push-style one-pass (SAX-like) interfaces. Together these enable YAML to support the processing of large documents, such as a transaction log, or continuous streams, such as a feed from a production machine.1.3.Relation to XMLNewcomers to YAML often search for its correlation to the eXtensible Markup Language (XML). While the two languages may actually compete in several application domains, there is no direct correlation between them.YAML is primarily a data serialization language. XML was designed to be backwards compatible with the Standard Gen-eralized Markup Language (SGML) and thus had many design constraints placed on it that YAML does not share. Inheriting SGML's legacy, XML is designed to support structured documentation, where YAML is more closely targeted at data structures and messaging. Where XML is a pioneer in many domains, YAML is the result of lessons learned from XML and other technologies.It should be mentioned that there are ongoing efforts to define standard XML/YAML mappings. This generally requires that a subset of each language be used. For more information on using both XML and YAML, please visit ht-tp:///xml/index.html.1.4.TerminologyThis specification uses key words based on RFC2119 [/rfc/rfc2119.txt] to indicate requirement level.In particular, the following words are used to describe the actions of a YAML processor:May The word may, or the adjective optional, mean that conforming YAML processors are permitted, but need not behave as described.Should The word should, or the adjective recommended, mean that there could be reasons for a YAML processor to deviate from the behavior described, but that such deviation could hurt interoperability and should thereforebe advertised with appropriate notice.Must The word must, or the term required or shall, mean that the behavior described is an absolute requirement of the specification.Chapter 2. PreviewThis 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. CollectionsYAML'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 mapping key: value pair.Example 2.2. Mapping Scalars to Scalars (player statistics)hr: 65avg: 0.278rbi: 147Example 2.1. Sequence of Scalars (ball players)- Mark McGwire - Sammy Sosa - Ken GriffeyExample 2.4. Sequence of Mappings (players' statistics)- name: Mark McGwire hr: 65 avg: 0.278- name: Sammy Sosa hr: 63 avg: 0.288Example 2.3. Mapping Scalars to Sequences (ball clubs in each league)american:- Boston Red Sox - Detroit Tigers - New York Yankees national:- New York Mets - Chicago Cubs - Atlanta BravesYAML 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.Example 2.6. Mapping of MappingsMark McGwire: {hr: 65, avg: 0.278}Sammy Sosa: { hr: 63, avg: 0.288 }Example 2.5. Sequence of Sequences- [name , hr, avg ]- [Mark McGwire, 65, 0.278]- [Sammy Sosa , 63, 0.288]2.2. StructuresYAML uses three dashes (“---”) to separate documents within a stream. Three dots ( “...”) indicate the end of a doc-ument without starting a new one, for use in communication channels. Comment lines begin with the Octothorpe (usually called the “hash” or “pound” sign - “#”).Example 2.8. Play by Play Feed from a Game---time: 20:03:20player: Sammy Sosa action: strike (miss)...---time: 20:03:47player: Sammy Sosa action: grand slam ...Example 2.7. Two Documents in a Stream (each with a leading comment)# Ranking of 1998 home runs ---- Mark McGwire - Sammy Sosa - Ken Griffey# Team ranking ---- Chicago Cubs- St Louis CardinalsRepeated nodes are first identified by an anchor (marked with the ampersand - “&”), and are then aliased (referenced with an asterisk - “*”) thereafter.Example 2.10. Node for “Sammy Sosa ”appears twice in this document---hr:- Mark McGwire# Following node labeled SS - &SS Sammy Sosa rbi:- *SS # Subsequent occurrence - Ken GriffeyExample 2.9. Single Document with Two Comments---hr: # 1998 hr ranking - Mark McGwire - Sammy Sosa rbi:# 1998 rbi ranking - Sammy Sosa - Ken GriffeyA 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.Example 2.12. In-Line Nested Mapping---# products purchased - item : Super Hoop quantity: 1- item : Basketball quantity: 4- item : Big Shoes quantity: 1Example 2.11. Mapping between Sequences? - Detroit Tigers - Chicago cubs :- 2001-07-23? [ New York Yankees, Atlanta Braves ]: [ 2001-07-02, 2001-08-12, 2001-08-14 ]2.3. ScalarsScalar content can be written in block form using a literal style (“|”) where all line breaks count. Or they can be written with the folded style (“>”) where each line break is folded to a space unless it ends an empty or a “more indented” line.Example 2.14. In the plain scalar,newlines become spaces--- Mark McGwire's year was crippled by a knee injury.Example 2.13. In literals,newlines are preserved# ASCII Art --- |\//||\/|| // || ||__Example 2.16. Indentation determines scopename: Mark McGwire accomplishment: >Mark set a major league home run record in 1998.stats: |65 Home Runs0.278 Batting AverageExample 2.15. Folded newlines preserved for "more indented" and blank lines>Sammy Sosa completed another fine season with great stats. 63 Home Runs0.288 Batting Average What a year!YAML's flow scalars include the plain style (most examples thus far) and quoted styles. The double quoted style provides escape sequences. The single quoted style is useful when escaping is not needed. All flow scalars can span multiple lines;line breaks are always folded.Example 2.18. Multi-line Flow Scalarsplain:This unquoted scalar spans many lines.quoted: "So does this quoted scalar.\n"Example 2.17. Quoted Scalarsunicode: "Sosa did fine.\u263A"control: "\b1998\t1999\t2000\n"hexesc: "\x13\x10 is \r\n"single: '"Howdy!" he cried.'quoted: ' # not a ''comment''.'tie-fighter: '|\-*-/|'2.4. TagsIn YAML, untagged nodes are given an type depending on the application. The examples in this specification generally use the “seq ” [/type/seq.html], “map ” [/type/map.html] and “str ” [/type/str.html] types from the YAML tag repository [/type/index.html]. A few examples also use the “int ” [/type/int.html] and “float ” [/type/float.html] types. The repository includes additional types such as “null ” [/type/null.html], “bool ” [/type/bool.html],“set ” [/type/set.html] and others.Example 2.20. Floating Pointcanonical: 1.23015e+3exponential: 12.3015e+02sexagecimal: 20:30.15fixed: 1,230.15negative infinity: -.inf not a number: .NaNExample 2.19. Integerscanonical: 12345decimal: +12,345sexagecimal: 3:25:45octal: 014hexadecimal: 0xCExample 2.22. Timestampscanonical: 2001-12-15T02:59:43.1Ziso8601: 2001-12-14t21:59:43.10-05:00spaced: 2001-12-14 21:59:43.10 -5date: 2002-12-14Example 2.21. Miscellaneousnull: ~true: y false: nstring: '12345'Explicit typing is denoted with a tag using the exclamantion point (“!”) symbol. Global tags are URIs and may be specified in a shorthand form using a handle. Application-specific local tags may also be used.Example 2.24. Global Tags%TAG ! tag:,2002:--- !shape# Use the ! handle for presenting # tag:,2002:circle - !circlecenter: &ORIGIN {x: 73, y: 129} radius: 7- !linestart: *ORIGINfinish: { x: 89, y: 102 }- !labelstart: *ORIGIN color: 0xFFEEBBtext: Pretty vector drawing.Example 2.23. Various Explicit Tags---not-date: !!str 2002-04-28picture: !!binary |R0lGODlhDAAMAIQAAP//9/X 17unp5WZmZgAAAOfn515eXv Pz7Y6OjuDg4J+fn5OTk6enp 56enmleECcgggoBADs=application specific tag: !something | The semantics of the tag above may be different for different documents.Example 2.26. Ordered Mappings# ordered maps are represented as # a sequence of mappings, with # each mapping having one key --- !!omap- Mark McGwire: 65- Sammy Sosa: 63- Ken Griffy: 58Example 2.25. Unordered Sets# sets are represented as a # mapping where each key is# associated with the empty string --- !!set? Mark McGwire ? Sammy Sosa ? Ken Griff2.5. Full Length ExampleBelow are two full-length examples of YAML. On the left is a sample invoice; on the right is a sample log file.Example 2.28. Log File---Time: 2001-11-23 15:01:42 -5User: ed Warning:This is an error message for the log file ---Time: 2001-11-23 15:02:31 -5User: ed Warning:A slightly different error message.---Date: 2001-11-23 15:03:17 -5User: ed Fatal:Unknown variable "bar"Stack:- file: TopClass.py line: 23 code: |x = MoreObject("345\n") - file: MoreClass.py line: 58 code: |- foo = barExample 2.27. Invoice--- !<tag:,2002:invoice>invoice: 34843date : 2001-01-23bill-to: &id001 given : Chris family : Dumars address:lines: |458 Walkman Dr. Suite #292city : Royal Oak state : MI postal : 48046ship-to: *id001product:- sku : BL394D quantity : 4description : Basketball price : 450.00 - sku : BL4438H quantity : 1description : Super Hoop price : 2392.00tax : 251.42total: 4443.52comments:Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.Chapter3.Processing YAML Information YAML is both a text format and a method for presenting any data structure in this format. Therefore, this specification defines two concepts: a class of data objects called YAML representations, and a syntax for presenting YAML representations as a series of characters, called a YAML stream. 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 applic-ation. This chapter describes the information structures a YAML processor must provide to or obtain from the application.YAML information is used in two ways: for machine processing, and for human consumption. The challenge of reconciling these two perspectives is best done in three distinct translation stages: representation, serialization, and presentation. Rep-resentation addresses how YAML views native data structures to achieve portability between programming environments.Serialization concerns itself with turning a YAML representation into a serial form, that is, a form with sequential access constraints. Presentation deals with the formatting of a YAML serialization as a series of characters in a human-friendly manner.Figure3.1.Processing OverviewA YAML processor need not expose the serialization or representation stages. It may translate directly between native datastructures 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.3.1.ProcessesThis section details the processes shown in the diagram above. Note a YAML processor need not provide all these processes.For example, a YAML library may provide only YAML input ability, for loading configuration files, or only output ability, for sending data to other applications.3.1.1.RepresentYAML represents any native data structure using three node kinds: the sequence, the mapping and the scalar. By sequence we mean an ordered series of entries, by mapping we mean an unordered association of unique keys to values, and by scalar we mean any datum with opaque structure presentable as a series of Unicode characters. Combined, these primitives generate directed graph structures. These primitives were chosen because they are both powerful and familiar: the sequence corresponds to a Perl array and a Python list, the mapping corresponds to a Perl hash table and a Python dictionary. The scalar represents strings, integers, dates and other atomic data types.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:,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.3.1.2.SerializeFor 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.3.1.3.PresentThe final output process is presenting the YAML serializations as a character stream in a human-friendly manner. To maximize human readability, YAML offsers 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 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 of the application, in general this process should guided by the preferences of the user.3.1.4.ParseParsing is the inverse process of presentation, it takes a stream of characters and produces a series of events. Parsing discards all the details introduced in the presentation process, reporting only the serialization events. Parsing can fail fue to ill-formed input.poseComposing takes a series of serialization events and produces a representation graph. Composing discards all the serializ-ation details introduced in the serialization process, producing only the representation graph. Composing can fail due to any of several reasons, detailed below.3.1.6.ConstructThe 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, content format, indentation levels etc. Construction can fail due to the unavailability of the required native data types.rmation ModelsThis section specifies the formal details of the results of the above processes. To maximize data portability between pro-gramming 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 beused 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 ap-plication information will be consistent and portable between various programming environments.rmation Models3.2.1.Representation GraphYAML's representation of native data is a rooted, connected, directed graph of tagged nodes. By “directed graph” we meana set of nodes and directed edges (“arrows”), where each edge connects one node to another (see a formal definition[/dads/HTML/directedGraph.html]). 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 and 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.Figure3.3.Representation Model3.2.1.1.NodesYAML 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 which the node's 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 or it could even contain itself (directly or indirectly).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 arbitrarynodes, the same node may be used as the value of several key:value pairs, and a mapping could even containitself as a key or a value (directly or indirectly).When appropriate, it is convenient to consider sequences and mappings together, as collections. In this view, sequences are treated as mappings with integer keys starting at zero. Having a unified collections view for sequences and mappings is helpful both for creating practical YAML tools and APIs and for theoretical analysis.3.2.1.2.TagsYAML represents type information of native data structures with a simple identifier, called a tag. Global tags are are URIs [/rfc/rfc2396.txt] and hence globally unique across all applications. The “tag”: URI scheme。