yaml 订阅
YAML
信息
操作系统
跨平台
开发语言
开源协议
未知
YAML
YAML(IPA: /ˈjæməl/,尾音类似camel骆驼)是一个可读性高,用来表达资料序列的编程语言。YAML参考了其他多种语言,包括:XML、C语言、Python、Perl以及电子邮件格式RFC2822。Clark Evans在2001年在首次发表了这种语言[1] ,另外Ingy döt Net与Oren Ben-Kiki也是这语言的共同设计者。目前已经有数种编程语言或脚本语言支援(或著说解析)这种语言。 YAML是"YAML Ain't a Markup Language"(YAML不是一种置标语言)的递归缩写。在开发的这种语言时,YAML 的意思其实是:"Yet Another Markup Language"(仍是一种置标语言),但为了强调这种语言以数据做为中心,而不是以置标语言为重点,而用返璞词重新命名。
收起全文
精华内容
参与话题
问答
  • YamlYaml学习笔记

    千次阅读 2016-08-01 13:36:57
    在XML泛滥的情况下,YAML的出现的确让人眼前一亮,在初步学习了YAML以后,粗略的总结了一下,拿出来和大家分享。 [MindMap] [参考文档]YAML Specification YAML 数据类型说明 [摘要] YAML的设计目的 YAML描述: ...

     

    YAML何许物也?在XML泛滥的情况下,YAML的出现的确让人眼前一亮,在初步学习了YAML以后,粗略的总结了一下,拿出来和大家分享。

    [MindMap]



    [参考文档]
    YAML Specification 
    YAML 数据类型说明

    [摘要]
    YAML的设计目的
    YAML描述: [注释, 文档, 数据结构, 数据类型, 其他]


     

    YAML的设计目的

    1、容易人类阅读
    2、适合表示程序语言的数据结构
    3、可用于不同程序间交换数据
    4、支持泛型工具
    5、支持串行处理?
    6、丰富的表达能力和可扩展性
    7、易于使用

    粗看了specification以后感觉最好的是“容易人类阅读”,对比一下下面的xml和yaml的代码块:

    # xml代码块:

    <site>
        <name>sina</name>
        <url>http://www.sina.com.cn</url> 
    </site>
    <site>
        <name>google</name>
        <url>http://www.google.com</url>
    </site>


    # YAML代码块

    ---
    site: 
        name: sina 
        url : http://www.sina.com.cn
    ---
    site:
        name: google
        url : http://www.google.com

    或:

    ---
    site: {name: sina, url: http://www.sina.com.cn}
    ---
    site: {name: google, url: http://www.google.com}


    YAML利用缩进或者是explicit indicatior(如上面的{})来表示属性的嵌套,更为直观和simple。
     


     

    YAML描述

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


    先来看看YAML里的主要标记:

    (1)注释:

    举个例子:
    # Comment Example
    # Profile Of Mary
    Mary:
        - name: Mary
        - age  : 19   # age property


    (2)文档(document):

    现在还不明白文档是什么意思,既然YAML定义是data serialization,暂时把一个doucment视为一个object序列化后得到的yaml配置信息

    # documents example
        ---
    site: {name: sina, url: http://www.sina.com.cn}
    ---
    site: {name: google, url: http://www.google.com}



    (3)数据结构:
    YAML的设计者认为在配置文件中所要表达的数据内容有三种类型:标量(Scalar,如字符串和整数等)、序列(Sequence,如数组)和Mapping(类似hash的key/value pair)。

    sequence型主要是用来表示数组类型的数据。下图描述了YAML中Sequence型数据的表示法:


    mapping数据类型主要用来表示key: value对类型的数据。YAML描述方式见下图:


    最后,我们用YAML来描述一本书《单元测试知道-c#版》

    # 《单元测试之道-c#版》描述
    ---  # begin of document
    书名  : '单元测试之道-C#版'
    出版社: '电子工业出版社'
    原作者: ['Andrew Hunt', 'David Thomas']
    译者  : 
        - 陈伟柱
         - 陶文
    前二章节  : 
        - 第一章: 序言
        - 第二章: 你的首个单元测试计划

      #end of document

    YAML推荐使用空格作为缩进,避免了在不同编辑器中对tab的表示形式不同而可能产生误解。

    =============================================================================================================

    [TOC]
    #YAML预研文档

    ##YAML概要

    [YAML](http://yaml.org/)是"YAML Ain't a Markup Language"(YAML不是一种置标语言)的递归缩写,早先YAML的意思其实是:"Yet Another Markup Language"(另外一种置标语言),但为了强调这种语言以数据做为中心,而不是以置标语言为重点,而用返璞词重新命名,YAML的官方定义很简单,即**一种人性化的数据格式定义语言**,其主要功能用途类似于XML或JSON,YAML使用空白字符和分行来分隔数据,且巧妙避开各种封闭符号,如:引号、括号等,以避免这些符号在复杂层次结构中变得难以辨认。YAML的语法与高阶语言类似,可以很简单地表述*序列(java中的list)、杂凑表(java中的map)、标量(java中的基本类型等)*数据结构,它重点强调可阅读性。

    ##YAML vs XML

    与YAML相似的数据格式定义语言是XML,YAML比XML优越性表现在
    > **优势:**

    > -  YAML的可读性好
    > - YAML和脚本语言的交互性好
    > - YAML使用实现语言的数据类型
    > - YAML有一个一致的信息模型
    > - YAML易于实现

    上面5条是XML不足的地方,同时,YAML也具有XML的下列优点:

    > - YAML可以基于流来处理
    > - YAML表达能力强,扩展性好

    YAML类似于XML的数据描述语言,语法比XML简单很多,YAML试图用一种比XML更敏捷的方式,来完成XML所完成的任务。

    ----------

    ##YAML vs JSON

    JSON的语法其实是YAML的子集,大部分的JSON文件都可以被YAML的剖析器剖析。虽然大部分的数据分层形式也可以使用类似JSON的格式,不过YAML并不建议这样使用,除非这样编写能让文件可读性增加,更重要的是,YAML的许多扩展在JSON是找不到的,如:*进阶资料形态*、*关系锚点*、*字串不需要引号*、*映射资料形态会储存键值的顺序*等。

    ##YAML用途

    ###脚本语言

    由于实现简单,解析成本很低,YAML特别适合在脚本语言中使用。列一下现有的语言实现:Ruby,Java,Perl,Python,PHP,OCaml,JavaScript,除了Java,其他都是脚本语言。

    ###序列化

    YAML比较适合做序列化。因为它是宿主语言数据类型直转的。

    ###配置文件

    YAML做配置文件也不错。写YAML要比写XML快得多(**无需关注标签或引号**),并且比ini文档功能更强。

    ###调试

    由于其很强的阅读性,用于调试过程中dump出信息供分析也是一种比较方便的做法。

    ##YAML缺陷与不足

    YAML没有自己的数据类型的定义,而是使用实现语言的数据类型。一个YAML文件,在不同语言中解析后得到的数据类型可能会不同,由于其兼容性问题,不同语言间的数据流转不建议使用YAML。

    ##YAML语法与范例

    > - YAML使用可打印的Unicode字符,可使用UTF-8或UTF-16
    > - 使用**空白字符**(不能使用<kbd>Tab</kbd>)分层,同层元素左侧对齐
    > - 单行注解由井字号(<kbd> #</kbd> )开始,可以出现在行中任何位置
    > - 每个清单成员以单行表示,并用短杠+空白(<kbd>-  </kbd>)起始
    > - 每个杂凑表的成员用冒号+空白(<kbd>:  </kbd>)分开键和值
    > - 杂凑表的键值可以用问号 (<kbd>?</kbd>)起始,表示多个词汇组成的键值
    > - 字串一般不使用引号,但必要的时候可以用引号框住
    > - 使用双引号表示字串时,可用倒斜线(<kbd>\</kbd>)进行特殊字符转义
    > - 区块的字串用缩排和修饰词(非必要)来和其他资料分隔,有新行保留(使用符号<kbd>|</kbd>)或新行折叠(使用符号<kbd>></kbd>)两种方式
    > - 在单一档案中,可用连续三个连字号(<kbd>---</kbd>)区分多个档案
    > - 可选择性的连续三个点号(<kbd>...</kbd>)用来表示档案结尾(在流式传输时非常有用,不需要关闭流即可知道到达结尾处)
    > - 重复的内容可使从参考标记星号 (<kbd>*</kbd>)复制到锚点标记(<kbd>&</kbd>)
    > - 指定格式可以使用两个惊叹号 ( !! ),后面接上名称

    ```
    receipt:     Oz-Ware Purchase Invoice
    date:        2007-08-06
    customer:
        given:   Dorothy
        family:  Gale
    items:
        - part_no:   A4786
          descrip:   Water Bucket (Filled)
          price:     1.47
          quantity:  4
        - part_no:   E1628
          descrip:   High Heeled "Ruby" Slippers 
          price:     100.27
          quantity:  1
    bill-to:  &id001
        street: | 
                123 Tornado Alley
                Suite 16
        city:   East Westville
        state:  KS
    ship-to:  *id001   
    specialDelivery:  >
        Follow the Yellow Brick
        Road to the Emerald City.
        Pay no attention to the 
        man behind the curtain.
    ...
    ```
    这个文件的的顶层由七个键值组成:其中一个键值"items",是个两个元素构成的清单,清单中的两个元素同时也是包含了四个键值的杂凑表。
    文件中重复的部分处理方式:使用锚点(&)和参考(*)标签将"bill-to"杂凑表的内容复制到"ship-to"杂凑表。也可以在文件中加入选择性的空行,以增加可读性。

    ##YAML的JAVA实现

    YAML已经有了多种语言不少实现,详见[YAML官网](http://yaml.org/)。
    一般YAML文件扩展名为.yaml,比如John.yaml,其内容为:
    ```
    name: John Smith
    age: 37
    children:
        - name: Jimmy Smith
          age: 15
        - name: Jenny Smith
          age: 12
    spouse:
        name: Jane Smith
        age: 25
    ```

    > 由于yaml的超强可读性,我们了解到:John今年37岁,两个孩子Jimmy 和Jenny活泼可爱,妻子Jane年轻美貌,而且年仅25岁,一个幸福的四口之家。
    对John.yaml进行java描述,抽象出一个Person类,如下:
    ```
    public class Person {
        private String name;
        private int age;
        private Person sponse;
        private Person[] children;
        // setXXX, getXXX方法略.
    }
    ```
    现在我们使用java装配一个Jone:
    ```
        Person john = new Person();
        john.setAge(37);
        john.setName("John Smith");
        Person sponse = new Person();
        sponse.setName("Jane Smith");
        sponse.setAge(25);
        john.setSponse(sponse);
        Person[] children = {new Person(), new Person()};
        children[0].setName("Jimmy Smith");
        children[0].setAge(15);
        children[1].setName("Jenny Smith");
        children[1].setAge(12);
        john.setChildren(children);
    ```

    ###使用SnakeYAML实现

    项目主页:http://code.google.com/p/snakeyaml/
    使用手册:https://code.google.com/p/snakeyaml/wiki/Documentation
    SnakeYAML是一个标准的YAML的java实现,它有以下特点:
    > - 完全支持YAML 1.1,可以跑通规范中的所有示例
    > - 支持YAML的所有类型
    > - 支持UTF-8/UTF-16的输入和输出
    > - 提供了本地java对象的序列化和反序列化的高层API
    > - 提供相对合理的错误提示信息

    使用SnakeYAML将john dump出来,**如果有引用相同对象,则dump出到yaml文件会自动使用<kbd>&</kbd>和<kbd>*</kbd>进行锚点和引用**:
    ```
    DumperOptions options = new DumperOptions();
    options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
    Yaml yaml = new Yaml(options);
    //Yaml yaml = new Yaml();
    String dump = yaml.dump(john);
    System.out.println(dump);
    ```
    内容如下:
    ```
    !!Person
    age: 37
    children:
    - age: 15
      children: null
      name: Jimmy Smith
      sponse: null
    - age: 12
      children: null
      name: Jenny Smith
      sponse: null
    name: John Smith
    sponse:
      age: 25
      children: null
      name: Jane Smith
      sponse: null
    ```
    现在用SnakeYAML把yaml load进来,**如果yaml文件中使用了<kbd>&</kbd>和<kbd>*</kbd>,则会自动对load出来的对象赋相同的值**:
    ```
    Yaml yaml = new Yaml();
    Object load = yaml.load(new FileInputStream(new File("jhon.yaml")));
    System.out.println(load.getClass());
    System.out.println(yaml.dump(load));
    ```

    ```
    Yaml yaml = new Yaml(options);
    Person person = yaml.loadAs(inputStream, Person.class);
    System.out.println(person.getSponse().getChildren().length);
    ```
    如果一个yaml文件中有多个文档,由<kbd>---</kbd>分割,解析如下:
    ```
    Yaml yaml = new Yaml();
            int counter = 0;
            for (Object data : yaml.loadAll(input)) {
                System.out.println(data);
                counter++;
            }
    ```
    保存一个Map对象:
    ```
    Map<String, Object> data = new HashMap<String, Object>();
            data.put("name", "Silenthand Olleander");
            data.put("race", "Human");
            data.put("traits", new String[] { "ONE_HAND", "ONE_EYE" });
            Yaml yaml = new Yaml();
            String output = yaml.dump(data);
            System.out.println(output);
        // or
        StringWriter writer = new StringWriter();
        yaml.dump(data, writer);
        System.out.println(writer.toString());
    ```
    将多个文档dump出到同一个yaml文件中去:
    ```
    List<Integer> docs = new LinkedList<Integer>();
        for (int i = 1; i < 4; i++) {
            docs.add(i);
        }
        DumperOptions options = new DumperOptions();
        //options.setCanonical(true);
        options.explicitStart(true);
        Yaml yaml = new Yaml(options);
        System.out.println(yaml.dump(docs));
        System.out.println(yaml.dumpAll(docs.iterator()));
    ```
    ```
    --- [1, 2, 3]

    --- 1
    --- 2
    --- 3
    ```
    YAML与java类型对照表:
    YAML     | JAVA
    -------- | -------
    !null     |null
    !!bool     |Boolean
    !!int     |Integer, Long, BigInteger
    !!float     |Double
    !!binary     |String
    !!timestamp     |java.util.Date, java.sql.Date, java.sql.Timestamp
    !!omap, !!pairs     |List of Object[]
    !!set     |Set
    !!str     |String
    !!seq     |List
    !!map     |Map

    集合的默认实现是:
    > - List:  ArrayList
    > - Map:  LinkedHashMap

    ###使用JYaml实现

    JYaml(**最新版本是2007年的,可以考虑放弃了**),使用JYaml把Jone “Dump” 出来:
    ```
        File dumpfile = new File("John_dump.yaml");
        Yaml.dump(john, dumpfile);
    ```
    下面我们看看John_dump.yaml是什么样子:
    ```
    --- !yaml.test.internal.Person
    age: 37
    children: !yaml.test.internal.Person[]
      - !yaml.test.internal.Person
        age: 15
        name: Jimmy Smith
      - !yaml.test.internal.Person
        age: 12
        name: Jenny Smith
    name: John Smith
    sponse: !yaml.test.internal.Person
      age: 25
      name: Jane Smith
    ```
    其中!yaml.test.internal.Person是一些类型的信息。load的时候需要用。
    现在用JYaml把Jone_dump.yaml load进来:
    ```
        Person john2 = (Person) Yaml.loadType(dumpfile, Person.class);
    ```
    还可以用下面的代码dump出没有类型信息的John.yaml:
    ```
    Yaml.dump(john,dumpfile, true);
    ```
    我们再来看看JYaml对流处理的支持,为简便起见,我们只是把同一个john写10次:
    ```
        YamlEncoder enc = new YamlEncoder(new FileOutputStream(dumpfile));
        for(int i=0; i<10; i++){
            john.setAge(37+i);
            enc.writeObject(john);
            enc.flush();
        }
       enc.close();
    ```
    下面再把这十个对象一个一个读出来(注意while循环退出的方式):
    ```
       YamlDecoder dec = new YamlDecoder(new FileInputStream(dumpfile));
       int age = 37;
       while(true){
           try{
               john = (Person) dec.readObject();
               assertEquals(age, john.getAge());
               age++;
           }catch(EOFException eofe){
               break;
           }
       }
    ```

     

    参考:

    http://blog.csdn.net/conquer0715/article/details/42108061

    http://www.cnblogs.com/chwkai/archive/2009/03/01/249924.html

     

    欢迎关注公众号:

    展开全文
  • 【配置】yaml简介

    2020-06-07 10:03:44
    YAMLYAML Ain’t Markup Language)以数据为中心,比json、xml更适合做配置文件。 YAML语法 基本语法 k: v:表示一个键值对(空格必须有)。 以空格的缩进来控制层级关系,只要是左对齐的一列数据都是同一层级的。...

    springboot使用一个全局的配置文件(名字是固定的):

    • application.properties
    • application.yml

    配置文件的作用:修改springboot自动配置的默认值。

    YAML

    YAML(YAML Ain’t Markup Language)以数据为中心,比json、xml更适合做配置文件。

    YAML语法

    基本语法

    k: v:表示一个键值对(空格必须有)。
    以空格的缩进来控制层级关系,只要是左对齐的一列数据都是同一层级的。

    server:
      port: 8081
    

    属性和值是大小写敏感的。

    值的写法

    字面量:数字、字符串、布尔

    字符串默认不用加双引号或单引号
    “字符串”:转义字符串里的特殊字符
    ‘字符串’:不转义字符串里的特殊字符

    对象、Map

    friend:
    	name: zhangsan
    	age: 20
    

    行内写法:

    friend: {name: zhangsan, age: 20}
    

    数组(List、Set)

    用**- 值**表示数组中的一个元素

    pets:
     - cat
     - dog
     - pig
    

    行内写法:

    pets: [cat, dog, pig]
    

    yaml配置文件值获取

    示例:
    pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.0.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.qublog</groupId>
        <artifactId>springboot_config</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot_config</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.junit.platform</groupId>
                <artifactId>junit-platform-launcher</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!-- 导入配置文件处理器,配置文件进行绑定就会有提示 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    application.yml

    server:
      port: 8081
    
    person:
      lastName: zhangsan
      age: 20
      boss: false
      birth: 2020/12/12
      maps: {k1: v1, k2: v2}
      lists:
        - lisi
        - zhaosi
      dog:
        name: gou
        age: 2
    

    Dog类:

    package com.qublog.springboot_config.bean;
    
    public class Dog {
        private String name;
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Dog{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    Person类:

    package com.qublog.springboot_config.bean;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    
    //将配置文件中配置的每一个属性的值,映射到这个组件中
    //@ConfigurationProperties告诉sspringboot将本类中所有的属性和配置文件中相关的配置进行绑定
    //prefix:配置文件中哪个下面的属性进行一一映射
    //只有这个组件是容器中的组件,才能提供的@ConfigurationProperties功能
    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person {
        private String lastName;
        private Integer age;
        private Boolean boss;
        private Date birth;
    
        private Map<String, Object> maps;
        private List<Object> lists;
        private Dog dog;
    
        public String getLastName() {
            return lastName;
        }
    
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Boolean getBoss() {
            return boss;
        }
    
        public void setBoss(Boolean boss) {
            this.boss = boss;
        }
    
        public Date getBirth() {
            return birth;
        }
    
        public void setBirth(Date birth) {
            this.birth = birth;
        }
    
        public Map<String, Object> getMaps() {
            return maps;
        }
    
        public void setMaps(Map<String, Object> maps) {
            this.maps = maps;
        }
    
        public List<Object> getLists() {
            return lists;
        }
    
        public void setLists(List<Object> lists) {
            this.lists = lists;
        }
    
        public Dog getDog() {
            return dog;
        }
    
        public void setDog(Dog dog) {
            this.dog = dog;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "lastName='" + lastName + '\'' +
                    ", age=" + age +
                    ", boss=" + boss +
                    ", birth=" + birth +
                    ", maps=" + maps +
                    ", lists=" + lists +
                    ", dog=" + dog +
                    '}';
        }
    }
    

    SpringbootConfigApplication类:

    package com.qublog.springboot_config;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringbootConfigApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringbootConfigApplication.class, args);
        }
    }
    

    SpringbootConfigApplicationTests类:

    package com.qublog.springboot_config;
    
    import com.qublog.springboot_config.bean.Person;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class SpringbootConfigApplicationTests {
    
        @Autowired
        Person person;
    
        @Test
        void contextLoads() {
            System.out.println(person);
        }
    
    }
    
    展开全文
  • yaml格式

    千次阅读 2019-06-18 17:59:05
    yaml中允许表示三种格式,分别为常量值、对象和数组 例如: 其中#作为注释,yaml中只有行注释 基本格式要求: 1.大小写敏感;2.使用缩进代表层级关系; 3.缩进只能使用空格,不能使用tab键,不要求空格个数,...

     yaml中允许表示三种格式,分别为常量值、对象和数组

    例如:

    其中#作为注释,yaml中只有行注释

    基本格式要求:

    1.大小写敏感;2.使用缩进代表层级关系;

    3.缩进只能使用空格,不能使用tab键,不要求空格个数,只需要相同层级左对齐(一般2或4个空格)。

    对象:

    使用冒号代表,格式为key:  value。冒号后要有一个空格:

    可使用缩进表示层级关系:

    yaml中还支持流式(flow)语法表示对象,比如上面例子可写为:

    较为复杂的对象格式,可以使用问号加一个空格代表一个复杂的key,配合一个冒号加一个空格代表一个value:

    意思即对象的属性是一个数组[complexkey1, complexkey2],对应的值也是一个数组[complexvalue1, complexvalue2]

    使用流式语法即为[complexkey1,complexkey2]:[complexvalue1,complexvalue2]

    数组

    使用一个短横线加一个空格表示一个数组项:

    当然也可以有这样的写法:

    可以简单的理解为[[java,LOL]]

    一个相对复杂的例子:

    意思是companies属性是一个数组,每一个数组元素又是由id、name、price三个属性构成;

    使用流式语法表示为:

    常量:

    yaml中提供了多种常量结构,包括整数、浮点数、字符串、null、日期、布尔值、时间。

    使用+代表时区

    特殊符号

    1. ---  yaml可以在同一个文件中,使用---表示一个文档的开始:

    代表定义了两个profile,一个是development,一个是production;也常使用---来分割不同的内容,比如记录日志:

    2. ...和---配合使用,在一个配置文件中代表一个文件的结束:

    相当于在一个yaml中连续写了两个yaml配置项

    3. !!yaml中使用!!做类型强行转换:

    相当于把数字和布尔值类型强转换为字符串

    将数组解析为set集合,简单理解,转化的内容就是[{Mark McGwire: 65}, {Sammy Sosa: 63}, {Ken Griffy: 58}],去掉重复。

    4. >在字符串中折叠换行, |保留换行,这两个符号是yaml中字符串经常使用的符号,比如:

    那么,accomplishment的结果为:将换行符转化成了空格,需要主意的是,每行的文本钱一定要有一个空格

     

    stats的结果是:

    常见|符号多用于yaml中配置html片段:

    5.引用。重复的内容在yaml中可以使用&符号来完成锚点定义,使用*来完成锚点引用,例如:

    可以看到,在hr中,使用&SS为Sammy Sosa设置了一个锚点引用,名称为SS,在rbi中,使用*SS来引用锚点:

    我们也可以这样定义:

    注意:不能独立的定义锚点,比如不能直接这样写: &SS Sammy Sosa;另外,锚点能够定义更复杂的内容,比如:

    那么hr相当于引用了default的数组,注意,hr: *default要写在同一行。

    6.合并内容。主要和锚点配合使用,可以将一个锚点内容直接合并到一个对象中,例如:

    在merge中定义了四个锚点,分别在sample中使用。

    sample1中,<<: *CENTER意思是引用{x: 1, y:2},并且合并到sample1中,那么合并的结果为:sample1={r=10, y=2,x=1}

    sample2中,<<: [*CENTER, *BIG]意思是联合引用{x:1, y:2}和{R: 10},并且合并到sample2中,那么结果为sample2={other=haha,x=1,y=2}

    sample3中,引入了*CENTER,*BIG,还使用了r: 100覆盖了引入的r:10,所以sample3值为sample3={r=100, y=2, x=1}

    转自:https://www.cnblogs.com/caibao666/p/10238497.html

    展开全文
  • Yaml:基本语法使用

    千次阅读 2019-08-20 20:57:31
    YAML是”YAML Ain’t a Markup Language”(YAML不是一种置标语言)的递归缩写,早先YAML的意思其实是:”Yet Another Markup Language”(另外一种置标语言) YAML语法 YAML使用可打印的Unicode字符,可使用UTF-...

    YAML介绍

    YAML是”YAML Ain’t a Markup Language”(YAML不是一种置标语言)的递归缩写,早先YAML的意思其实是:”Yet Another Markup Language”(另外一种置标语言)

    YAML语法

    • YAML使用可打印的Unicode字符,可使用UTF-8或UTF-16
    • 使用空白字符(不能使用Tab)分层,同层元素左侧对齐
    • 单行注解由井字号( # )开始,可以出现在行中任何位置
    • 每个清单成员以单行表示,并用短杠+空白(- )起始
    • 每个杂凑表的成员用冒号+空白(: )分开键和值
    • 杂凑表的键值可以用问号 (?)起始,表示多个词汇组成的键值
    • 字串一般不使用引号,但必要的时候可以用引号框住
    • 使用双引号表示字串时,可用倒斜线(\)进行特殊字符转义
    • 区块的字串用缩排和修饰词(非必要)来和其他资料分隔,有新行保留(使用符号|)或新行折叠(使用符号>)两种方式
    • 在单一档案中,可用连续三个连字号(---)区分多个档案
    • 可选择性的连续三个点号(...)用来表示档案结尾(在流式传输时非常有用,不需要关闭流即可知道到达结尾处)
    • 重复的内容可使从参考标记星号 (*)复制到锚点标记(&)
    • 指定格式可以使用两个惊叹号 ( !! ),后面接上名称

    Yaml编写规范

     

      规范一:文档使用 Unicode 编码作为字符标准编码,例如 UTF-8

     

      规范二:使用“#”来表示注释内容

     

    # 客户订单
    date: 2015-02-01
    customer:
      - name: Jai
    items:
      - no: 1234         # 订单号
      - descript: cpu 

     

     

      规范三:使用空格作为嵌套缩进工具。通常建议使用两个空格缩进,不建议使用 tab (甚至不支持)

     

      规范四:序列表示

        1、使用“-”(横线) + 单个空格表示单个列表项

    --- # 文档开始
    - 第一章 简介
    - 第二章 设计目录

        2、使用"[]"表示一组数据

    --- # 文档开始
    [blue, red, green]

        3、组合表示。每个结构都可以嵌套组成复杂的表示结构

    --- # 文档开始
    - [blue, red, green]     # 列表项本身也是一个列表
    - [Age, Bag]
    - site: {osc:www.oschina.net, baidu: www.baidu.com}  # 这里是同 键值表 组合表示

     

      规范五:键值表

        1、使用 “:”(冒号) + 空格表示单个键值对

    # 客户订单
    date: 2015-02-01
    customer:
      - name: Jai
    items:
      - no: 1234         # 订单号
      - descript: cpu
      - price: ¥800.00

     

        2、使用"{}"表示一个键值表

    # 客户订单
    date: 2015-02-01
    customer:
      - name: Jai
    items: {no: 1234, descript: cpu, price: ¥800.00}

        3、"? " 问号+空格表示复杂的键。当键是一个列表或键值表时,就需要使用本符号来标记

     

     # 使用一个列表作为键
     ? [blue, reg, green]: Color
     # 等价于
     ? - blue
       - reg
       - gree
     : Color

     

        4、组合表示。每个结构都可以嵌套组成复杂的表示结构

    Color:
        - blue
        - red
        - green
     
     # 相当于 (也是 JSON 的表示)
     {Color: [blue, red, green]}
     div:
        - border: {color: red, width: 2px}
        - background: {color: green}
        - padding: [0, 10px, 0, 10px]
     # 使用缩进表示的键值表与列表项
     items:
        - item: cpu
          model: i3
          price: ¥800.00
        - item: HD
          model: WD
          price: ¥450.00
     # 上面使用 “-” 前导与缩进来表示多个列表项,相当于下面的JSON表示
     items: [{item:cpu, model:i3, price:¥800.00}, {item:HD, model:WD, price: ¥450.00}]

     

     

       规范六:文本块

        1、使用 “|” 和文本内容缩进表示的块:保留块中已有的回车换行。相当于段落块

    # 注意 ":" 与 "|" 之间的空格
    yaml: |
       JSON的语法其实是YAML的子集,大部分的JSON文件都可以被YAML的解释器解释。
       如果你想更深入的学习YAML,我建议你去 http://www.yaml.org 看看

        2、使用 “>” 和文本内容缩进表示的块:将块中回车替换为空格,最终连接成一行

    # 注意 ":" 与 ">" 之间的空格,另外可以使用空行来分段落
    yaml: >
       JSON的语法其实是YAML的子集,
       大部分的JSON文件都可以被YAML的解释器解释。
       如果你想更深入的学习YAML,我建议你去 http://www.yaml.org 看看

        3、使用定界符“”(双引号)、‘’(单引号)或回车表示的块:最终表示成一行

     

    yaml:     # 使用回车的多行,最终连接成一行。
       JSON的语法其实是YAML的子集,
       大部分的JSON文件都可以被YAML的解释器解释。
    
    yaml:     # 使用了双引号,双引号的好处是可以转义,即在里面可以使用特殊符号
       "JSON的语法其实是YAML的子集,
       大部分的JSON文件都可以被YAML的解释器解释。"

     

        4、当数据中含有空格或任意特殊字符,需要使用引号来包裹任何包含冒号的哈希值, 像这样:

    foo: "somebody said I should put a colon here: so I did"   # 然后这个冒号将会被结尾.

     

      规范七:数据类型的约定

        1、对一些常用数据类型的表示格式进行了约定,包括:

     

     integer: 12345     # 整数标准形式
     octal: 0o34        # 八进制表示,第二个是字母 o
     hex: 0xFF          # 十六进制表示
     
     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 日期格式
     spaced: 2015-08-23 21:59:43.10 -5      # ?

     

        2、“!”(叹号)显式指示类型,或自定义类型标识。单叹号通常是自定义类型,双叹号是内置类型,例如:

     

     isString: !!str 2015-08-23     # 强调是字符串不是日期数据
     picture: !!binary |            # Base64  图片
         R0lGODlhDAAMAIQAAP//9/X
         17unp5WZmZgAAAOfn515eXv
         Pz7Y6OjuDg4J+fn5OTk6enp
         56enmleECcgggoBADs=
    • #下面是内置类型
      
       !!int               # 整数类型
       !!float             # 浮点类型
       !!bool              # 布尔类型
       !!str               # 字符串类型
       !!binary            # 也是字符串类型
       !!timestamp         # 日期时间类型
       !!null              # 空值
       !!set               # 集合
       !!omap, !!pairs     # 键值列表或对象列表
       !!seq               # 序列,也是列表
       !!map               # 键值表
    
     
     #下面是一些例子:
    
     --- !!omap
     - Mark: 65
     - Sammy: 63
     - Key: 58
     --- !!set           # 注意,“?”表示键为列表,在这里列表为 null
     ? Mark
     ? Sammy
     ? Key
    
     # 下面是自定义的类型或标识
    
     %TAG ! tag:clarkevans.com,2002:   # % 是指令符号
     --- !shape
     # Use the ! handle for presenting
     # tag:clarkevans.com,2002:circle
     - !circle
       center: &ORIGIN {x: 73, y: 129}
       radius: 7
     - !line
       start: *ORIGIN
       finish: { x: 89, y: 102 }
     - !label
       start: *ORIGIN
       color: 0xFFEEBB
       text: Pretty vector drawing.

     

    #test.yaml(双叹号,强制转换类型)
    str: !!str 3.14
    int: !!int "123"
    
    输出:{'int': 123, 'str': '3.14'}    #明显能够看出123被强转成了int类型,而float型的3.14则被强转成了str型

      规范八:锚点与引用,定义数据的复用。  

    • 第一步:使用 “&” 定义数据锚点(即要复制的数据)

    • 第二步:使用 “*” 引用上述锚点数据(即数据的复制目的地)

       

       ---
       hr:
         - Mark McGwire
         # Following node labeled SS
         - &SS Sammy Sosa            # 定义要复制的数据
       rbi:
         - *SS # Subsequent occurrence   这里是数据复制目标
         - Ken Griffey

       

    参考链接:

    https://yaml.org/

    https://www.cnblogs.com/yxfeng/p/10396288.html

    展开全文
  • YAML最最基础语法

    万次阅读 多人点赞 2017-07-19 16:37:53
    正如YAML所表示的YAML Ain’t Markup Language,YAML 是一种简洁的非标记语言。YAML以数据为中心,使用空白,缩进,分行组织数据,从而使得表示更加简洁易读。一边学习规则一边可以在在线Demo这个YAML转化JSON网页中...
  • yaml文件的 锚点& 与 引用*

    千次阅读 2019-08-18 15:22:53
    yaml文件的 锚点& 与 引用* 简介 当yaml文件中出现多个重复内容时,可以通过 锚点& 与引用* ,实现引用锚点处内容的功能,从而在修改时,只需要修改锚点处的内容,即可在所有引用处生效 参考网址:...
  • YAML简介

    千次阅读 2019-03-03 17:26:06
    YAML是一个可读性高,用来表达数据序列的格式。YAML参考了其它多种语言,包括:C语言、Python、Perl,并从XML、电子邮件的数据格式中获得灵感。Clark Evans在2001年首次发表了这种语言。当前已经有数种编程语言或...
  • 【世界语言大全】yaml

    2018-12-19 17:01:46
    YAML是“YAML不是一种标记语言”的外语缩写;但为了强调这种语言以数据做为中心,而不是以置标语言为重点,而用返璞词重新命名。它是一种直观的能够被电脑识别的数据序列化格式,是一个可读性高并且容易被人类阅读,...
  • 我们学习Java,都是先介绍properties文件,使用properties文件配合Properties对象能够很方便的适用于应用配置上。然后在引入XML的时候,我们介绍properties格式在表现层级关系和结构关系的时候,十分欠缺,而XML在...
  • YAML详解 是什么

    万次阅读 2018-02-01 17:00:08
    1. 认识 YAML  YAML是一个类似 XML、JSON 的标记性语言。YAML 强调以数据为中心,并不是以标识语言为重点。因而 YAML 本身的定义比较简单,号称“一种人性化的数据格式语言”。 1.1 YAML 的设计目标: ...
  • YAML是什么

    千次阅读 2019-04-03 07:28:51
    YAML不是标记语言。YAML是一种对人友好的对各种程序语言的数据序列化标准。 YAML Aren't Markup Language, 递归缩写就变成了YAML. 语法类似于XML,但是比XML要简单很多。 YAML使用空白字符和分行来分隔资料,...
  • yaml文件

    千次阅读 2018-11-29 11:31:13
    1、在yaml里面,结构通过缩进来表示,连续的项目(如:数组元素、集合元素)通过减号“-”来表示,map结构里面的键值对(key/value)用冒号“:”来分割。yaml也有用来描述好几行相同结构数据的缩写语法,数组用“[]...
  • 在前面的文章中介绍了YAML使用的示例,以及如何使用python的pyyaml模块加载YAML文件并并行展示,这篇文章继续使用前文的示例代码和示例yaml文件进行说明。
  • YAML文件简介

    2019-11-07 10:11:10
    YAML 是专门用来写配置文件的语言,非常简洁和强大,远比 JSON 格式方便。 本文介绍 YAML 的语法,以JS-YAML的实现为例。你可以去在线 Demo验证下面的例子。 一、简介 YAML 语言(发音 /ˈjæməl/ )的设计...
  • yaml文件简介

    2019-07-15 17:15:31
    YAML 是专门用来写配置文件的语言,非常简洁和强大,远比 JSON 格式方便。 本文介绍 YAML 的语法,以JS-YAML的实现为例。你可以去在线 Demo验证下面的例子。 一、简介 YAML 语言(发音 /ˈjæməl/ )的设计...
  • Kubernetes之yaml文件详解(汇总-详细)

    万次阅读 多人点赞 2019-03-13 16:22:52
    YAML是专门用来写配置文件的语言,非常简洁和强大,使用比json更方便。它实质上是一种通用的数据串行化格式。 YAML语法规则: 大小写敏感 使用缩进表示层级关系 缩进时不允许使用Tal键,只允许使用空格 缩进的...
  • Yaml介绍及JYaml将数据写入yaml文件

    万次阅读 2017-12-01 20:38:28
     "YAML Ain't a Markup Language"(YAML不是一种置标语言)的递归缩写,早先YAML的意思其实是:"Yet Another Markup Language"(另外一种置标语言),但为了强调这种语言以数据做为中心,而不是以置标语言为重点,...
  • YAML文件

    2020-10-26 14:07:39
    YAML(资源清单文件、...2、YAML文件书写格式 介绍:YAML仍是一种标记语言。为了强调这种语言以数据作为中心,而不是以标记语言为重点,YAML是一个可读性高,用来表达数据序列的格式。 * 通过缩进表示层级关系 * 不
  • k8s 各类yaml文件

    万次阅读 2019-04-19 10:25:41
    deployment.yaml文件详解 Pod yaml文件详解 Service yaml文件详解 ingress.yaml详解 deployment.yaml文件详解 apiVersion: extensions/v1beta1 #接口版本 kind: Deployment #接口类型 metadata: name: cango-...
  • docker yaml文件 铃响了! Docker v1.13发布了! 在与Docker相关的讨论和研讨会期间,我收到的最常见问题通常与Swarm和Compose有关。 有人 :如何将Docker Compose与Docker Swarm结合使用? 我 :你不能! 您...
  • Kubernetes之YAML文件

    万次阅读 2018-03-02 22:12:05
    后文会说明定义YAML文件创建Pod和创建Deployment。 YAML语法规则: 大小写敏感 使用缩进表示层级关系 缩进时不允许使用Tal键,只允许使用空格 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可 ”#” 表示...
  • yaml配置文件的语法规范

    万次阅读 2020-06-02 12:55:45
    1、基本语法 k:(空格)v:表示一对键值对(空格必须有); 以空格的缩进来控制层级关系;只要是左对齐的一列数据,都是同一个层级的 server: port: 8081 path: /hello 属性和值也是大小写敏感;...
  • 读取通用Yaml文件

    2017-03-20 13:51:10
    <p>I have a config file in YAML. I want to define a struct which is generic enough for this file. <p>Example: <pre><code>A: B: C: D: E: F: G: </code></pre> <p>Since there is no predefined ...
  • 动态更新Yaml文件

    2019-09-10 11:15:10
    err = yaml.Unmarshal(yamlFile, &p2) if err != nil { log.Fatalln(err) } var p = &person{} err := json.Unmarshal([]byte(dat), p) if err != nil { log.Fatalln(err) } } </code></pre> ...
  • 目录Python中YAML文件的操作一、概要1. yaml文件规则2. yaml文件数据结构3. 使用场景二、Python中的使用1. pyyaml2. ruamel三、参考 Python中YAML文件的操作 一、概要 在开发容器发布系统的时候,由于需要调用k8s的...
  • YAML文件使用指南

    2019-07-31 19:32:47
    YAML文件使用指南YAML文件简介YAML文件的语法格式对象YAML注释YAML文件注意事项: YAML文件简介 YAML不是一种标记语言”的外语缩写;但为了强调这种语言以数据做为中心,而不是以置标语言为重点,而用返璞词重新命名...
  • yaml文件解析详解

    2019-09-26 01:20:18
    yaml文件其实也是一种配置文件类型,相比较ini,conf配置文件来说,更加的简洁,操作也更加简单,同时可以存放不同类型的数据,不会改变原有数据类型,所有的数据类型在读取时都会原样输出,yaml文件依赖python的第...
  • 解析动态Yaml文件

    2018-02-24 08:40:01
    <p>I know from go using the gopkg.in/yaml.v2 package, i can parse through the yaml file, if all the values are the same, for example: <pre><code> type Secrets struct { Keys []struct { Key string `...
  • Python读写yaml文件

    2020-02-16 14:45:29
    一、yaml文件介绍 yaml是一个专门用来写配置文件的语言。 1. yaml文件规则 区分大小写; 使用缩进表示层级关系; 使用空格键缩进,而非Tab键缩进 缩...
  • yaml文件 .yml

    万次阅读 多人点赞 2017-08-06 16:34:14
    YAML文件简介  我们可能在spring配置文件里见到过.yml格式的东东,配置文件不都是.propertie或者.xml文件吗?.yml是什么鬼,今天我带你们来一探究竟。  YAML(Yet Another Markup Language)(发音 /ˈjæməl/ )...

空空如也

1 2 3 4 5 ... 20
收藏数 168,291
精华内容 67,316
关键字:

yaml