前言

本文简单介绍toml；并且和json转化做对比，以及我对toml设计的理解。

参考：

TOML: 简体中文 v1.0.0

json和toml转化工具

在线JSON转toml-toml转JSON - bejson在线工具

正文

数组

说白了，就是一个变量名，有多个变量的值。值的类型，可以相同，可以不同。

integers = [ 1, 2, 3 ]
colors = [ "红", "黄", "绿" ]
nested_array_of_ints = [ [ 1, 2 ], [3, 4, 5] ]
nested_mixed_array = [ [ 1, 2 ], ["a", "b", "c"] ]
string_array = [ "所有的", '字符串', """是相同的""", '''类型''' ]

# 允许混合类型的数组
numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ]
contributors = [
  "Foo Bar <foo@example.com>",
  { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" }
]

对应josn

{
  "integers": [ 1,2,3 ],
  "colors": ["红",黄","绿"],
  "nested_array_of_ints": [[1,2],[3,4,5]],
  "nested_mixed_array": [[1,2],["a","b","c"]],
  "string_array": ["所有的","字符串","是相同的","类型"],
  "numbers": [0.1,0.2,0.5,1,2,5],
  "contributors": [
    "Foo Bar <foo@example.com>",
    {
      "name": "Baz Qux",
      "email": "bazqux@example.com",
      "url": "https://example.com/bazqux"
    }
  ]
}

表

在json中对应“对象”；要注意的是json中，对象有的有名字，有的没有名字。

toml方括号，就说明用的是“表”。也就是json中的对象。

创建表的方法：

#创建了sites对象，内容有site1
[sites]
site1 = "www.runoob.com"

#创建了“嵌套”对象
[dog]
[dog."tater.man"]
[dog."tater.man".type]
name = "pug"

#等价于上面
dog."tater.man".type.name = "pug"

例子：

{
    "name":"runoob",
    "alexa":10000,
    "sites": {
        "site1":"www.runoob.com",
        "site2":"m.runoob.com",
        "site3":"c.runoob.com"
    }
}


转成toml
name = "runoob"
alexa = 10000
[sites]
site1 = "www.runoob.com"
site2 = "m.runoob.com"
site3 = "c.runoob.com"

嵌套

{
  "dog": {
    "tater": {
      "type": {
        "name": "pug"
      }
    }
  }
}


转成toml
[dog]
[dog.tater]
[dog.tater.type]
name = "pug"
#等价于上面——没有括号
dog.tater.type.name = "pug"

demo

[merter1.VoltageSurge]
 STimeStamp= ["1","2","3"]
 ETimeStamp= ["4","5","6"]
 
[merter1.VoltageDip]
 STimeStamp= ["1","2","3"]
 ETimeStamp= ["1","2","3"]

[merter2.VoltageSurge]
 STimeStamp= ["1","2","3"]
 ETimeStamp= ["1","2","3"]
[merter2.VoltageDip]
 STimeStamp= ["1","2","3"]
 ETimeStamp= ["1","2","3"]

const auto data = toml::parse("C:/Users/45428/Desktop/test.toml");
	for (const auto& kv : data.as_table()) {
		const toml::value& value = kv.second;
		// 遍历子表
		const toml::table& sub_table = value.as_table();
		for (const auto& sub_kv : sub_table) {
			const toml::key& sub_key = sub_kv.first;
			const toml::value& sub_value = sub_kv.second;

			const auto STimeStamp = toml::find<std::vector<string>>(sub_value, "STimeStamp");
			const auto ETimeStamp = toml::find<std::vector<string>>(sub_value, "ETimeStamp");
		}
	}

内联表

和“表”一样。

他的存在就是让文件变得更加紧凑相对于“表”来说。

既然是为了更紧凑，就不允许他换行。

你要内联表，就得在大括号里定义完，不允许再起一行后面增加。或者用内联表去增加一般的表。

#表
[name]
first = "Tom"
last = "Preston-Werner"
[point]
x = 1
y = 2
[animal]
type.name = "pug"

#内联表——更紧凑——上下都一样
name = { first = "Tom", last = "Preston-Werner" }
point = { x = 1, y = 2 }
animal = { type.name = "pug" }

表数组

就是表里嵌套数组；

对应的json就是对象嵌套数组。

【【数组名字】】

例子：

{
  "products": [#数组products——两个元素
    {
      "name": "Hammer",
      "sku": 738594937
    },
    {
      "name": "Nail",
      "sku": 284758393
    }
  ],
  "products1": [#数组products1——一个元素
    {
      "name": "Hammer",
      "sku": 738594937
    }
  ]
}

#数组products
[[products]]
name = "Hammer"
sku = 738594937
[[products]]
name = "Nail"
sku = 284758393

#数组products1
[[products1]]
name = "Hammer"
sku = 738594937

嵌套

[[fruits]]
name = "apple"

[fruits.physical]  # 子表
color = "red"
shape = "round"

[[fruits.varieties]]  # 嵌套表数组
name = "red delicious"

[[fruits.varieties]]
name = "granny smith"

[[fruits]]
name = "banana"

[[fruits.varieties]]
name = "plantain"


{
  "fruits": [
    {
      "name": "apple",
      "physical": {
        "color": "red",
        "shape": "round"
      },
      "varieties": [
        {
          "name": "red delicious"
        },
        {
          "name": "granny smith"
        }
      ]
    },
    {
      "name": "banana",
      "varieties": [
        {
          "name": "plantain"
        }
      ]
    }
  ]
}

表和表数组的区别

【对象名】：toml的表，json的对象

{
  "a": {}
}

【【对象名】】：toml的表数组，json的数组里放对象

{
  "a": [
    {}
  ]
}

嵌套：

【a.b】a对象嵌套b对象

{
  "a": {
    "b": {}
  }
}

【【a.b】】a数组嵌套b对象

[[a.b]]

{
  "a": {
    "b": [
      {}
    ]
  }
}

嵌套的都是对象