精华内容
下载资源
问答
  • yaml文件properties和properties转yaml

    千次阅读 2019-03-28 10:19:00
    yaml文件properties和properties转yaml 首先要引入依赖  <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson...

    yaml文件转properties和properties转yaml

    1. 首先要引入依赖  
    <dependency>
           <groupId>com.fasterxml.jackson.dataformat</groupId>
           <artifactId>jackson-dataformat-yaml</artifactId>
           <version>2.9.4</version>
    </dependency>
    
    <dependency>
           <groupId>com.fasterxml.jackson.dataformat</groupId>
           <artifactId>jackson-dataformat-properties</artifactId>
           <version>2.9.4</version>
    </dependency>

      2.直接上工具类

      

    package config.center.config.utils;
    
    import com.fasterxml.jackson.core.JsonParser;
    import com.fasterxml.jackson.core.JsonToken;
    import com.fasterxml.jackson.dataformat.javaprop.JavaPropsFactory;
    import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
    import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;
    import com.fasterxml.jackson.dataformat.yaml.YAMLParser;
    
    import java.io.*;
    import java.nio.charset.Charset;
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * @program: config
     * @description: 转换工具类
     * @author: xujingyang
     * @create: 2019-03-27 12:16
     **/
    public class TransferUtils {
    
        private static final String ENCODING = "utf-8";
    
        public static void yml2Properties(String path) {
            final String DOT = ".";
            List<String> lines = new LinkedList<>();
            try {
                YAMLFactory yamlFactory = new YAMLFactory();
                YAMLParser parser = yamlFactory.createParser(
                        new InputStreamReader(new FileInputStream(path), Charset.forName(ENCODING)));
    
                String key = "";
                String value = null;
                JsonToken token = parser.nextToken();
                while (token != null) {
                    if (JsonToken.START_OBJECT.equals(token)) {
                        // do nothing
                    } else if (JsonToken.FIELD_NAME.equals(token)) {
                        if (key.length() > 0) {
                            key = key + DOT;
                        }
                        key = key + parser.getCurrentName();
    
                        token = parser.nextToken();
                        if (JsonToken.START_OBJECT.equals(token)) {
                            continue;
                        }
                        value = parser.getText();
                        lines.add(key + "=" + value);
    
                        int dotOffset = key.lastIndexOf(DOT);
                        if (dotOffset > 0) {
                            key = key.substring(0, dotOffset);
                        }
                        value = null;
                    } else if (JsonToken.END_OBJECT.equals(token)) {
                        int dotOffset = key.lastIndexOf(DOT);
                        if (dotOffset > 0) {
                            key = key.substring(0, dotOffset);
                        } else {
                            key = "";
                            lines.add("");
                        }
                    }
                    token = parser.nextToken();
                }
                parser.close();
    
                System.out.println(lines);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        public static void properties2Yaml(String path) {
            JsonParser parser = null;
            JavaPropsFactory factory = new JavaPropsFactory();
            try {
                parser = factory.createParser(
                        new InputStreamReader(new FileInputStream(path), Charset.forName(ENCODING)));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                YAMLFactory yamlFactory = new YAMLFactory();
                YAMLGenerator generator = yamlFactory.createGenerator(
                        new OutputStreamWriter(new FileOutputStream(path), Charset.forName(ENCODING)));
    
                JsonToken token = parser.nextToken();
    
                while (token != null) {
                    if (JsonToken.START_OBJECT.equals(token)) {
                        generator.writeStartObject();
                    } else if (JsonToken.FIELD_NAME.equals(token)) {
                        generator.writeFieldName(parser.getCurrentName());
                    } else if (JsonToken.VALUE_STRING.equals(token)) {
                        generator.writeString(parser.getText());
                    } else if (JsonToken.END_OBJECT.equals(token)) {
                        generator.writeEndObject();
                    }
                    token = parser.nextToken();
                }
                parser.close();
                generator.flush();
                generator.close();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
    }

      

      转换起来还是很方便的~

     

    posted @ 2019-03-28 10:19 oldmonk 阅读( ...) 评论( ...) 编辑 收藏
    展开全文
  • yaml

    2019-01-09 17:13:42
    YAML::Node config = YAML::LoadFile("config.yaml"); //执行文件同级目录 if (config["lastLogin"]) //如果文件节点有成员节点lastLogin { //获取并打印文件节点的成员...

    https://github.com/jbeder/yaml-cpp/wiki/Tutorial

     

    典型的加载YAML文件的例子:

    YAML::Node config = YAML::LoadFile("config.yaml");  //执行文件同级目录

    if (config["lastLogin"]) //如果文件节点有成员节点lastLogin

    {

    //获取并打印文件节点的成员节点lastLogin,转化为数据结构DateTime

     std::cout << "Last logged in: " << config["lastLogin"].as<DateTime>() << "\n";

    }

    const std::string username = config["username"].as<std::string>();

    const std::string password = config["password"].as<std::string>(); login(username, password);

    config["lastLogin"] = getCurrentDateTime();

    std::ofstream fout("config.yaml"); fout << config;

     

     

    基本解析和节点编辑

    在文件YAML里面所有信息以节点形式表示。可以检查节点的类型如:YAML::NodeType::Sequence/Null/Scalar/Map/Undefined

    集合节点(Sequence组或map结构)与STL的vector和map结构用法一致

     

    Sequence的用法如下

    YAML::Node primes = YAML::Load("[2, 3, 5, 7, 11]");

     for (std::size_t i=0;i<primes.size();i++)

     {

    std::cout << primes[i].as<int>() << "\n";

    } // or:

    for (YAML::const_iterator it=primes.begin();it!=primes.end();++it)

    { std::cout << it->as<int>() << "\n"; }

    primes.push_back(13);

    assert(primes.size() == 6);

     

    Map的用法如下:

    YAML::Node lineup = YAML::Load("{1B: Prince Fielder, 2B: Rickie Weeks, LF: Ryan Braun}");

    for(YAML::const_iterator it=lineup.begin();it!=lineup.end();++it)

     { std::cout << "Playing at " << it->first.as<std::string>() << " is " << it->second.as<std::string>() << "\n"; }

     lineup["RF"] = "Corey Hart";

    lineup["C"] = "Jonathan Lucroy";

     assert(lineup.size() == 5);

     

    创建节点

    YAML::Node node; // starts out as null新建一个空的节点

    node["key"] = "value"; // it now is a map node 节点为MAP结构

    node["seq"].push_back("first element"); // node["seq"] automatically becomes a  sequence //节点为数组结构

    node["seq"].push_back("second element");

    node["mirror"] = node["seq"][0]; // this creates an alias//创建了一个引用

    node["seq"][0] = "1st element"; // this also changes node["mirror"] node["mirror"] = "element #1"; // and this changes node["seq"][0] - they're really the "same" node

    node["self"] = node; // you can even create self-aliases

    node[node["mirror"]] = node["seq"]; // and strange loops :)

     

    生成的节点为

    &1 key: value

    &2 seq: [&3 "element #1", second element]

    mirror: *3

    self: *1

    *3 : *2

     

    数组节点转换为map节点

    YAML::Node node = YAML::Load("[1, 2, 3]");

    node[1] = 5; // still a sequence, [1, 5, 3] 仍然是一个数组

    node.push_back(-3) // still a sequence, [1, 5, 3, -3]  仍然是一个数组

    node["key"] = "value"; // now it's a map! {0: 1, 1: 5, 2: 3, 3: -3, key: value} //转换为map节点

     

     

    下面这个例子也可以转换为MAP

    YAML::Node node = YAML::Load("[1, 2, 3]");

    node[3] = 4; // still a sequence, [1, 2, 3, 4]

    node[10] = 10; // now it's a map! {0: 1, 1: 2, 2: 3, 3: 4, 10: 10}

     

     

    与本地数据结构互相转换

    YAML::Node node = YAML::Load("{pi: 3.14159, [0, 1]: integers}");

    // this needs the conversion from Node to double 转换为double类型

    double pi = node["pi"].as<double>();

    // this needs the conversion from double to Node

    node["e"] = 2.71828;

    // this needs the conversion from Node to std::vector<int> (*not* the other way around!)

    std::vector<int> v;

    v.push_back(0);

    v.push_back(1);

    std::string str = node[v].as<std::string>();

    与自定义类型互相转换

    自定义类型为:

    struct Vec3 { double x, y, z; /* etc - make sure you have overloaded operator== */ };

     

    特化模板类YAML::convert<>

    namespace YAML {   

    template<>

    struct convert<Vec3> {

     

    static Node encode(const Vec3& rhs) {

    Node node;

    node.push_back(rhs.x);

    node.push_back(rhs.y);

    node.push_back(rhs.z);

    return node; }

     

    static bool decode(const Node& node, Vec3& rhs)

    { if(!node.IsSequence() || node.size() != 3)

    { return false; }

    rhs.x = node[0].as<double>();

    rhs.y = node[1].as<double>();

     rhs.z = node[2].as<double>();

     return true; }

     

    };

    }

     

    使用方法:

    YAML::Node node = YAML::Load("start: [1, 3, 0]");

    Vec3 v = node["start"].as<Vec3>();

    node["end"] = Vec3(2, -1, 0);

     

     

    https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML

    基本发布

    YAML::Emitter相当于一个输出流YAML::Emitter,可以通过c_str()获取值。

    #include "yaml-cpp/yaml.h"

    int main()

     {

     YAML::Emitter out;

     out << "Hello, World!";

     std::cout << "Here's the output YAML:\n" << out.c_str(); // prints "Hello, World!"

     return 0; }

     

     

    简单的列表和Maps

    YAML::Emitter out;

    out << YAML::BeginSeq;    //开始列表

    out << "eggs";

    out << "bread";

    out << "milk";

    out << YAML::EndSeq;      //结束列表

     

    生成:

    - eggs

    - bread

    - milk

     

    YAML::Emitter out;

    out << YAML::BeginMap;    //开始Map

    out << YAML::Key << "name";   //

    out << YAML::Value << "Ryan Braun";  //

    out << YAML::Key << "position";

    out << YAML::Value << "LF";

    out << YAML::EndMap;    //结束Map

     

    生成:

    name: Ryan Braun

    position: LF

     

    还可以嵌套:

    YAML::Emitter out;

    out << YAML::BeginMap;

    out << YAML::Key << "name";

    out << YAML::Value << "Barack Obama";

    out << YAML::Key << "children";

    out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;

    out << YAML::EndMap;

     

    生成:

    name: Barack Obama

    children:

    - Sasha

    - Malia

     

    使用Manipulators控制输出格式

    YAML::Emitter out;

    out << YAML::Literal << "A\n B\n C";

    输出

    |

    A

     B

     C

     

     

    YAML::Emitter out;

    out << YAML::Flow;

    out << YAML::BeginSeq << 2 << 3 << 5 << 7 << 11 << YAML::EndSeq;

     

    输出

    [2, 3, 5, 7, 11]

     

    注释:

    YAML::Emitter out; o

    ut << YAML::BeginMap;

    out << YAML::Key << "method";

    out << YAML::Value << "least squares";

    out << YAML::Comment("should we change this method?");

    out << YAML::EndMap;

    输出

    method: least squares # should we change this method?

     

     

    aliases/anchors

    YAML::Emitter out;

    out << YAML::BeginSeq;

    out << YAML::Anchor("fred");

    out << YAML::BeginMap;

    out << YAML::Key << "name" << YAML::Value << "Fred";

    out << YAML::Key << "age" << YAML::Value << "42";

    out << YAML::EndMap;

    out << YAML::Alias("fred");

    out << YAML::EndSeq;

    输出

    - &fred

     name: Fred

     age: 42

    - *fred

    已经给 std::vector, std::list, 和 std::map重载了符号 <<

    std::vector <int> squares;

    squares.push_back(1);

    squares.push_back(4);

    squares.push_back(9);

    squares.push_back(16);

    std::map <std::string, int> ages;

    ages["Daniel"] = 26;

    ages["Jesse"] = 24;

    YAML::Emitter out;

    out << YAML::BeginSeq;

    out << YAML::Flow << squares;

    out << ages;

    Out << YAML::EndSeq;

    输出

    - [1, 4, 9, 16]

    - Daniel: 26

      Jesse: 24

     

    可以为自定义类型重载符号<<

    struct Vec3 { int x; int y; int z; };

    YAML::Emitter& operator << (YAML::Emitter& out, const Vec3& v) {

        out << YAML::Flow;

        out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;

        return out;

    }

     

     

       

    展开全文
  • YAML

    2013-10-19 11:36:00
    YAML 简介及其与 XML 的不同之处 自从有了递归定义,大家都爱上了这种起名方式,YAML 也是。YAML 的定义是:“YAML Ain ’ t a Markup Language”,即:YAML 不是一种标记语言的递归缩写。要问 YAML 到底是不是一种...

    YAML 简介及其与 XML 的不同之处

    自从有了递归定义,大家都爱上了这种起名方式,YAML 也是。YAML 的定义是:“YAML Ain ’ t a Markup Language”,即:YAML 不是一种标记语言的递归缩写。要问 YAML 到底是不是一种标记语言呢?答案:是的。有意思的是:在 YAML 开发的早期,YAML 其实参考了许多其他语言,如 XML, SDL 及电子邮件格式等等,并最终把自己定义为:“Yet Another Markup Language”。既然明明是标记语言,为什么后来又改名换姓,非说自己不是标记语言了呢?其实名字的更换正是为了强调 YAML 的与众不同:YAML 是以数据为设计语言的重点的,而不是像 XML 以标记为重点。实事上,正是因为这样一种设计理念使得 YAML 在后来的不少应用中取代 XML,成为一种可读性高,易于表达数据序列的编程语言。

    YAML 的数据组织主要依靠的是空白,缩进,分行等结构。这使得 YAML 语言很容易上手。我们就以 YAML 官方网站上给出的一个例子来看看 YAML 文件的书写(如清单 1 所示)。相信熟悉 XML 的人都会感受到 YAML 是多么的简洁明了!

    YAML 的语法十分简单:用“-”来表示一些序列的项(Sequence),如清单 1 里的产品(product)有两样东西(Basketball 和 Super Hoop)组织为一个序列;用“:”来表示一对项目(Map)里的栏目(Key)和其相应的值(Value),比如清单 1 发票里的时间(date)的值是 2001-01-23,这就是一个 Map。这些就是 YAML 里最重要的语法了。如果想知道其他语法的细节可以参看 YAML 官方网页里的参考卡片(reference card):http://www.yaml.org/refcard.html


    清单 1. 用 YAML 表达的一个购物发票

    				
     --- !clarkevans.com/^invoice 
     invoice: 34843 
     date : 2001-01-23 
     bill-to: &id001 
      given : Chris 
      family : Dumars 
      address: 
      lines: | 
      458 Walkman Dr. 
      Suite #292 
      city : Royal Oak 
      state : MI 
      postal : 48046 
     ship-to: *id001 
     product: 
      - sku : BL394D 
      quantity : 4 
      description : Basketball 
      price : 450.00 
      - sku : BL4438H 
      quantity : 1 
      description : Super Hoop 
      price : 2392.00 
     tax : 251.42 
     total: 4443.52 
     comments: > 
      Late afternoon is best. 
      Backup contact is Nancy 
      Billsmer @ 338-4338. 
    
    

     

    正因为 YAML 的语法和组织结构简单巧妙,YAML 很容易就可以插入另一个 YAML 文件,甚至其他类型的文件,包括 XML, SDL, JSON 等。相反,如果要在 XML 里插入 YAML,相信了解 XML 的朋友都知道,那是要加很多符号(Potential Sigils)才能完成。

    通过上面的举例,我们可以看出,YAML 较 XML 而言可读性更好,也更易于实现。但 YAML 的优点远不止于此。当 YAML 诞生不久的时候,其应用还只在动态编程语言如 Perl,Python, Ruby,及当时还应用得不算广泛的 java 编程中。而现如今 YAML 的支持库已包括 C/C++,C#/.NET,PHP 等。可以说,几乎在如今流行的编程语言中,YAML 已经无处不在。

    事实上,纵观程序语言的发展,从 C 到 C++,Java,再到动态脚本语言 Perl,Python,PHP, 直到如今相当之流行的 Ruby,人们越来越摈弃那些规则复杂,语法深奥的语言,取而代之的则是灵活简单,易读易写的,越来越趋近人类阅读书写习惯的程序语言。在数据的序列化上,这种趋势其实是一样的。YAML 作为可以和 XML 一样扩展性强,表达力强且基于流操作的语言,凭借着自身在可读性,易实现,与脚本语言易交互,于宿主语言的数据结构类型易使用等各方面优势,在数据序列化格式领域正成为越来越为人们喜爱的一种语言。

    本文的后续两个章节将从开发应用和配置文件两个方面以及 C++ 和 Ruby 这两种语言的角度,以实例介绍 YAML 的使用方法和优越之处。

     

    YAML 在开发应用中的使用及实例(C++)

    我们还以清单 1 里的发票数据为例。假如你有一个 C++ 开发的应用,其中的发票数据需要用一种语言来做序列化。选择 YAML,我们现在就把发票信息数据用 YAML 写在一个文件里的(具体请参考附件里的 invoice.yaml),然后下载并安装 yaml-cpp 库文件包,详细的方法和步骤可以参考 yaml-cpp 的官方网址上的说明:http://code.google.com/p/yaml-cpp/。接着我们就可以开始设计相应的 C++ 代码里的数据结构了。具体定义可以参看下面的清单 2.


    清单 2. 发票数据在 C++ 中的数据结构表示

    				
     struct Product { 
      std::string sku; 
      int quantity; 
      std::string description; 
      float price; 
     }; 
    
     struct Address { 
      std::string lines; 
      std::string city; 
      std::string state; 
      int postal; 
     }; 
    
     struct Bill { 
      std::string given; 
      std::string family; 
      Address address; 
     }; 
    
     struct Invoice { 
      int invoice; 
      std::string date; 
      Bill bill; 
      std::vector <Product> products; 
      float tax; 
      float total; 
      std::string comments; 
     }; 
    

     

    虽然 C++ 在标准模板库(STL)里有 Map,List 等与 YAML 相对应的数据类型,但是本例中为了更清晰看出 YAML 的用法,只简单构建了一些结构体与之对应。(从另一角度说,如果 YAML 用在像 Ruby 一样的脚本语言中,那么数据类型的对应将更加简单。在下一节的内容中将给出相关的实例。)另外,在 C++ 里,为了能够使用操作符“>>”(stream extraction operator)帮组我们完成 YAML 数据和 C++ 数据之间的赋值,我们需要对该操作符进行重载(overload)。具体实现可参考清单 3。


    清单 3. 重载运算符“>>”

    				
     void operator >> (const YAML::Node& node, Product& p) { 
      node["sku"] >> p.sku; 
      node["quantity"] >> p.quantity; 
      node["description"] >> p.description; 
      node["price"] >> p.price; 
     } 
    
     void operator >> (const YAML::Node& node, Address& a) { 
      node["lines"] >> a.lines; 
      node["city"] >> a.city; 
      node["state"] >> a.state; 
      node["postal"] >> a.postal; 
     } 
    
     void operator >> (const YAML::Node& node, Bill& b) { 
      node["given"] >> b.given; 
      node["family"] >> b.family; 
      node["address"] >> b.address; 
     } 
    
     void operator >> (const YAML::Node& node, Invoice& invoice) { 
      node["invoice"] >> invoice.invoice; 
      node["date"] >> invoice.date; 
      node["bill-to"] >> invoice.bill; 
    
      const YAML::Node& products = node["product"]; 
      for(unsigned i=0;i<products.size();i++) { 
      Product p; 
      products[i] >> p; 
      invoice.products.push_back(p); 
      } 
      
    				 node["tax"] >> invoice.tax; 
      node["total"] >> invoice.total; 
      node["comments"] >> invoice.comments; 
     } 
    

     

    在对 Product 的实现中,这里使用了 C++ 标准模板库里的 vector 容器以完成对多个 product 的赋值。

    有了数据结构,有了“>>”,那么当我们需要使用 YAML 数据的时候,只需读入 YAML 文件,交给 YAML 库的解析器(Parser)便高枕无忧了。相应的代码示例请参看清单 4。


    清单 4. 解析 YAML 数据

    				
     std::ifstream fin("invoice.yaml"); 
     YAML::Parser parser(fin); 
     YAML::Node doc; 
     parser.GetNextDocument(doc); 
     Invoice invoice; 
     doc >> invoice; 
    

     

    完整的代码示例请参考附件里的“invoice.cpp”和“invoice.yaml”。对于例子中的数据结构和方法,读者也可以构建更加完美的实现,这里仅是一简单示例。

     

    YAML 在配置文件中的使用及实例(Ruby)

    假设你在开发一个分布式系统,系统中有不同的节点(node)。那么配置文件里需要写明各种不同角色的节点各自的配置信息。如果你打算用 Ruby 语言来解析这种配置文件,那么用 YAML 来书写配置文件一定是你的不二选择。其实不仅仅是 Ruby,YAML 对于几乎所有的脚本语言来说,它的解析都比 XML 来得容易得多。

    Ruby 有着丰富灵活的数据结构,这使得 YAML 加 Ruby 的组合仿佛天生一对。比如:YAML 里的序列(Sequence)对应 Ruby 里的数组(Array);YAML 的一对项(Map)对应着 Ruby 里的 Hash 等等。详细的对应关系可见:http://www.yaml.org/YAML_for_ruby.html#folded_block_as_a_mapping_value

    假设我们的配置文件如清单 5 所示。


    清单 5. 配置文件示例

    				
     # 
     # Config file example 
     # 
    
     node_a: 
      conntimeout: 300 
      external: 
      iface: eth0 
      port: 556 
      internal: 
      iface: eth0 
     port: 778 
      broadcast: 
      client: 1000 
      server: 2000 
     node_b: 
      0: 
      ip: 10.0.0.1 
      name: b1 
      1: 
      ip: 10.0.0.2 
      name: b2 
    

     

    该配置文件定义了两种不同角色的节点(node),节点 node_a 是一个负责内外通信的节点。它的配置信息包括:其连接的 timeout 时间为 300 秒,外部及内部连接使用的接口(interface)及端口号(port),其中,内部连接还配置了广播的客户端和服务器端的端口。而 node_b 类型的节点共有两个节点组成,分别是 b1 和 b2,其配置信息包括 IP 地址和主机名。实际的配置当然会比这个文件复杂一些,这里仅仅是一个示例。当我们用 Ruby 语言解析该数据后(解析方法如清单 6 所示),就可以得到清单 7 里的数据结果。


    清单 6. 用 Ruby 解析 YAML 数据

    				
     #!/usr/bin/ruby 
     require 'yaml'
     yml = YAML::load(File.open('t.yml')) 
     p yml 
    

     

    大家可以看到,Ruby 语言解析 YAML 只需了了四行代码。其实我们完全可以打印行省掉,改写为“p YAML::load(File.open('t.yml'))”。也就是说,真正需要的就两行,require 和 YAML::load。再看结果,由于清单 7 里的结果在结构上比较复杂,也为了能和清单 5 中的 YAML 数据“看”起来相对应,这里做了一些缩进上的修改。由此我们可以更清晰得看出 YAML 数据在 Ruby 中的组织。


    清单 7. 数据解析结果

    				
     {"node_a"=>{ 
      "internal"=>{ 
      "broadcast"=>{ 
      "client"=>1000, 
      "server"=>2000 
      }, 
      "port"=>778, 
      "iface"=>"eth0"
      }, 
      "conntimeout"=>300, 
      "external"=>{ 
      "port"=>556, 
      "iface"=>"eth0"
      } 
     }, 
    "node_b"=>{ 
      0=>{ 
      "name"=>"b1", 
      "ip"=>"10.0.0.1" 
      }, 
      1=>{ 
      "name"=>"b2", 
      "ip"=>"10.0.0.2"
      } 
     } 
     } 
    

     

    在 Ruby 中使用 YAML 就是这么简单,你只有 require 了 YAML 的库,一切数据到 Ruby 数据结构的转换都轻而易举。其实 Ruby 的数据也可以 dump 为 YAML。感兴趣的朋友可以参看 YAML for Ruby 的文档:http://yaml4r.sourceforge.net/doc/

     

    YAML 的官方网址为http://www.yaml.org/

    展开全文
  • #include <fstream> ...int main() { YAML::Node node; assert(node.IsNull()); //初始化的节点是Null类型 node["key"] = "value"; //当你给它赋值键值对,它转变为Map类型 //node.forc
    #include <fstream>
    #include <yaml-cpp/yaml.h>
    #include <iostream>
    #include <assert.h>
    
    int main()
    {
       
        YAML::Node node;  
        assert
    展开全文
  • <p>Maps and pointers (to a struct, string, int, etc) are accepted as out values. If an internal pointer within a struct is not initialized, the yaml package will initialize it if necessary for ...
  • Port int `yaml:"port"` Uname string `yaml:"uname"` } </code></pre> <p>The format it puts my data into is: <pre><code>--- entrieslist: - name: entry1 command: addr: somewhere port: 22 uname: ...
  • yaml.yaml YAML的Lambda演算语法 除了从YAML到lambda演算本身的映射外,您还将找到我实现的模块来测试该语言的扩展性 risp-yaml 该模块在YAML语法之上实现了Lisp。 REPL $ cd interpreter.rust ...:fire: Int(42)
  • 这里写自定义目录标题YAMLYAML-CPP安装部署JSONJSONCPP安装部署代码头文件YamlToJsonJsonToYaml测试代码test.yaml文件测试代码输出结果总结其他 YAML YAML是“YAML不是一种标记语言”的外语缩写 (见前方参考资料...
  • YAML入门

    千次阅读 2018-12-19 08:58:00
    YAML YAML Ain’t Markup Language 和GNU一样,YAML是一个递归着说“不”的名字。不同的是,GNU对UNIX说不,YAML说不的对象是XML。因为: YAML的可读性好 YAML和脚本语言的交互性好 YAML使用实现语言的数据类型 ...
  • YAML书写规范

    万次阅读 2017-09-19 16:38:20
    1. 认识 YAML ... YAML是一个类似 XML、JSON 的标记性语言。...因而 YAML 本身的定义比较简单,号称“一种人性化的数据格式语言”。 1.1 YAML 的设计目标: 人类容易阅读 可
  • Yaml语法

    2020-02-06 20:28:45
    Yaml说明 YAML是"YAML Ain't a Markup Language"(YAML 不是一种标记语言的递归缩写。在开发的这种语言时,YAML 的意思其实是:"Yet Another Markup Language"(仍是一种标记语言),这种语言主要数据作为中心,而...
  • YAML文件

    2021-05-16 20:37:10
    YAML文件简介基本语法数据类型 简介 YAML 是 “YAML Ain’t a Markup Language”(YAML 不是一种标记语言)的递归缩写。其中,Ain’t 是口语化的表达,类似于 are not、is not,表示不是的意思。 YAML的适用于表达或...
  • RenamedC int `yaml:"c"` D []int `yaml:",flow"` } } func main() { t := T{} err := yaml.Unmarshal([]byte(data), &t) if err != nil { log.Fatalf("error: %v", err) } fmt.Printf("--- t:\n%v\...
  • yaml和properties java实现互

    千次阅读 2020-06-22 16:44:54
    yaml 和 properties 格式最大的区别在于,properties 是单层map格式。而yaml 是多层嵌套map格式。spring有snakeyaml实现了把多层map输出城yaml文件格式。这部分逻辑不用重写。实现的关键在于单层map如何多层。多层...
  • c++ 开发中利用yaml-cpp读写yaml配置文件

    万次阅读 多人点赞 2019-04-25 14:27:47
    在程序员的开发生涯中,读写配置文件必不可少。 配置文件有利于我们灵活配置工程,解决大量重复...今天的博文介绍的是如何在 C++ 开发中利用 yaml-cpp 开源库读写 yaml 配置文件。 如果有 Python 开发经验的同学...
  • YAML 学习

    2020-06-06 22:33:04
    YAML: YAML Ain't Markup Language What It Is: YAML is a human friendly data serialization standard for all programming languages. YAML(/ˈjæməl/,尾音类似camel骆驼)是一个可读性高,用来表达数据...
  • YAML语法

    2020-04-13 18:10:43
    yaml对于springboot全局属性设置的配置详情可查看链接属性对应,下面分析的是书写规则。 一、基础 k:(这里必须有空格)v:键值对 主要用缩进控制层级 二、值 字面量:值(int/char/boolean…) 字符串默认不用加上...
  • Yaml学习

    千次阅读 2015-10-15 20:15:16
    原文地址:... [TOC] #YAML预研文档 ##YAML概要 [YAML](http://yaml.org/)是"YAML Ain't a Markup Language"(YAML不是一种置标语言)的递归缩写,早先YAML的意思其实是:"Yet Another
  • yaml文件

    2021-03-22 15:29:26
    yaml文件其实也是一种配置文件,相比较ini和config来说功能更加强大,使用更加简单,操作更加灵活。yaml文件可以存储键值对,对象,数组。 它的基本语法规则如下: 大小写敏感 使用缩进表示层级关系 缩进时不允许...
  • yaml学习

    2017-10-22 20:28:20
    1.yaml概要 初次接触到yaml语言,是在做一个过程优化时,希望对一系列配置引入的数据得到规范。希望代码中获取数据简便,也希望规范能够明了易懂 在接触yaml应用前,基本使用的文件xml。而同样拥有语言规范的...
  • YamlYaml学习笔记

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

    2019-03-19 16:20:45
    文章目录1 YAML简介1.1 YAML是什么1.2 YAML优点2 YAML基本语法规则3 YAML中组织结构4 YAML中基础数据格式4.1 常量4.2 对象4.2 数组5 YAML中特殊符号5.1 类型符5.2 文本块5.3 锚点5.4 内容合并符5 YAML学习资源 ...
  • SpringBoot之YAML

    2020-08-09 21:42:06
    YAML 实体类为什么用Integer而不是intint如果设为空的话默认为0而Integer为Null properties配置文件只能存放键值对 yaml对空格的要求极为严格 yaml可以注入到我们的配置类中! yaml可以直接给实体类赋值 #yaml...
  • YAML 简介

    千次阅读 2008-04-26 22:50:00
    YAML Aint Markup Language和GNU一样,YAML是一个递归着说“不”的名字。不同的是,GNU对UNIX说不,YAML说不的对象是XML。YAML不是XML。 为什么不是XML呢?因为: YAML的可读性好。 YAML和脚本语言的交互性好。 YAML...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,577
精华内容 9,030
关键字:

intyaml转