程序常用配置文件格式介绍

# This is a comment
name=UserProfileServer
maxconns=1000
queuecap=10000
queuetimeout=300
loglevel=ERROR
logsize=10M
lognum=10
logpath=/usr/local/app/log

package main

import(
	"bufio"
 	"io"
 	"os"
	"fmt"
	"errors"
	"strings"
)

func ParseConf(confPath string) (map[string]string, error) {
	if confPath == ""{
		return nil, errors.New("param is ill")
	}
	
	f, err := os.Open(confPath)
	if err != nil {
  		return nil, err
 	}
 	defer f.Close()
	
	//store config info
	m := make(map[string]string)
	
	bfRd := bufio.NewReader(f)
	//read by line, the line terminator is '\n'
	for{
		line, err := bfRd.ReadString('\n')
		if err == nil || err == io.EOF{
			//ignore blank and comment line
			if strings.TrimSpace(line) != "" && strings.TrimSpace(line)[0] != '#'{
				vKV := strings.Split(line, "=")
				if len(vKV) == 2 {
					m[vKV[0]] = vKV[1]
				}
			}
			if err == io.EOF{
				return m, nil
			}
		} else {
			return nil, err
		}
	}
	return m, nil
}

func main(){
	mConf, _ := ParseConf("server.kv")
	fmt.Println(mConf)
}

map[loglevel:ERROR
 lognum:10
 logpath:/usr/local/app/log
 logsize:10M
 maxconns:1000
 name:UserProfileServer
 queuecap:10000
 queuetimeout:300
]

"firstName" : "John"

{ "firstName":"John" , "lastName":"Doe" }

{
"employees": [
	{ "firstName":"John" , "lastName":"Doe" },
	{ "firstName":"Anna" , "lastName":"Smith" },
	{ "firstName":"Peter" , "lastName":"Jones" }
]
}

{
    "-name": "UserProfileServer",
    "maxconns": "1000",
    "queuecap": "10000",
    "queuetimeout": "300",
    "loginfo": {
      "loglevel": "ERROR",
      "logsize": "10M",
      "lognum": "10",
      "logpath": "/usr/local/app/log"
    }
}

type Server  struct {
	Name         string `json:"-name"`
	Maxconns     string `json:"maxconns"`
	Queuecap     string `json:"queuecap"`
	Queuetimeout string `json:"queuetimeout"`
	Loginfo      struct {
		Loglevel string `json:"loglevel"`
		Logsize  string `json:"logsize"`
		Lognum   string `json:"lognum"`
		Logpath  string `json:"logpath"`
	} `json:"loginfo"`
}

package main

import(
        "encoding/json"
        "io/ioutil"
        "fmt"
        "os"
)

func main() {
  file, err := os.Open("server.json")
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  defer file.Close()

  data, err := ioutil.ReadAll(file)
  if err != nil {
    fmt.Printf("error: %v", err)
    return
  }
  v := Server{}
  err = json.Unmarshal(data, &v)
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  fmt.Printf("%+v\n", v)
}

{Name:UserProfileServer Maxconns:1000 Queuecap:10000 Queuetimeout:300 Loginfo:{Loglevel:ERROR Logsize:10M Lognum:10 Logpath:/usr/local/app/log}}

<!-- This is a comment --> 

<?xml version="1.0" encoding="UTF-8"?>
<server name="UserProfileServer">
	<maxconns>1000</maxconns>
	<queuecap>10000</queuecap>
	<queuetimeout>300</queuetimeout>
	<loginfo>
		<loglevel>ERROR</loglevel>
		<logsize>10M</logsize>
		<lognum>10</lognum>
		<logpath>/usr/local/app/log</logpath>
	</loginfo>
</server>

type Server struct {
	Name         string   `xml:"name,attr"`		//标签属性
	Maxconns     string   `xml:"maxconns"`
	Queuecap     string   `xml:"queuecap"`
	Queuetimeout string   `xml:"queuetimeout"`
	Loginfo      struct {
		Loglevel string `xml:"loglevel"`
		Logsize  string `xml:"logsize"`
		Lognum   string `xml:"lognum"`
		Logpath  string `xml:"logpath"`
	} `xml:"loginfo"`
} 

package main

import(
        "encoding/xml"
        "io/ioutil"
        "fmt"
        "os"    
)

func main() {
  file, err := os.Open("server.xml")
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  defer file.Close()

  data, err := ioutil.ReadAll(file)
  if err != nil {
    fmt.Printf("error: %v", err)
    return
  }
  v := Server{}
  err = xml.Unmarshal(data, &v) 
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  fmt.Printf("%+v\n", v)
}

{Name:UserProfileServer Maxconns:1000 Queuecap:10000 Queuetimeout:300 Loginfo:{Loglevel:ERROR Logsize:10M Lognum:10 Logpath:/usr/local/app/log}}

animal: pets

hash: { name: Steve, foo: bar } 

- Cat
- Dog
- Goldfish

-
 - Cat
 - Dog
 - Goldfish

animal: [Cat,Dog]

languages:
 - Ruby
 - Perl
 - Python 
websites:
 YAML: yaml.org 
 Ruby: ruby-lang.org 
 Python: python.org 
 Perl: use.perl.org 

{
  "languages": [
    "Ruby",
    "Perl",
    "Python"
  ],
  "websites": {
    "YAML": "yaml.org",
    "Ruby": "ruby-lang.org",
    "Python": "python.org",
    "Perl": "use.perl.org"
  }
}

boolean: 
    - TRUE	#true、True 都可以
    - FALSE	#false、False 都可以
float:
    - 3.14			#数值直接以字面量的形式表示
    - 6.8523015e+5	#可以使用科学计数法
int:
    - 123							#数值直接以字面量的形式表示
    - 0b1010_0111_0100_1010_1110	#二进制表示
null:
    nodeName: 'node'
    parent: ~  #使用~表示null
string:
    - 哈哈				#字符串默认不使用引号
    - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
    - newline
      newline2    #字符串可以拆成多行，每一换行符会被转化成一个空格
date:
    - 2018-02-17    #日期必须使用ISO 8601格式，即 yyyy-MM-dd
datetime: 
    -  2018-02-17T15:02:31+08:00    #时间使用 ISO 8601 格式，时间和日期之间使用 T 连接，最后使用 + 代表时区

defaults: &defaults
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *defaults

defaults:
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  adapter:  postgres
  host:     localhost

name: UserProfileServer
maxconns: 1000
queuecap: 10000
queuetimeout: 300
loginfo:
  loglevel: ERROR
  logsize: 10M
  lognum: 10
  logpath: /usr/local/app/log

type Server struct {
	Name         string `yaml:"name"`
	Maxconns     int    `yaml:"maxconns"`
	Queuecap     int    `yaml:"queuecap"`
	Queuetimeout int    `yaml:"queuetimeout"`
	Loginfo      struct {
		Loglevel string `yaml:"loglevel"`
		Logsize  string `yaml:"logsize"`
		Lognum   int    `yaml:"lognum"`
		Logpath  string `yaml:"logpath"`
	} `yaml:"loginfo"`
}

package main

import(
	"io/ioutil"
	"fmt"
	"os"	

	"yaml"
)

func main() {
  file, err := os.Open("server.yaml")
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  defer file.Close()

  data, err := ioutil.ReadAll(file)
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  v := Server{}
  err = yaml.Unmarshal(data, &v)
  if err != nil {
    fmt.Printf("error:%v\n", err)
    return
  }
  fmt.Printf("%+v\n", v)
}

{Name:UserProfileServer Maxconns:1000 Queuecap:10000 Queuetimeout:300 Loginfo:{Loglevel:ERROR Logsize:10M Lognum:10 Logpath:/usr/local/app/log}}

key = "value"

key = "value"
bare_key = "value"
bare-key = "value"
1234 = "value"

"127.0.0.1" = "value"
"character encoding" = "value"
"ʎǝʞ" = "value"
'key2' = "value"
'quoted "value"' = "value"

"名称" = "橙子"
"物理属性"."颜色" = "橙色"
"物理属性"."形状" = "圆形"
site."google.com" = true

{
  "名称": "橙子",
  "物理属性": {
    "颜色": "橙色",
    "形状": "圆形"
  },
  "site": {
    "google.com": true
  }
}

# 不要这样做
name = "Tom"
name = "Pradyun"

str = "我是一个字符串。\"你可以把我引起来\"。姓名\tJos\u00E9\n位置\t旧金山。"

\b         - backspace       (U+0008)
\t         - tab             (U+0009)
\n         - linefeed        (U+000A)
\f         - form feed       (U+000C)
\r         - carriage return (U+000D)
\"         - quote           (U+0022)
\\         - backslash       (U+005C)
\uXXXX     - unicode         (U+XXXX)
\UXXXXXXXX - unicode         (U+XXXXXXXX)

str1 = """
玫瑰是红色的
紫罗兰是蓝色的"""

# 在 Unix 系统，上面的多行字符串可能等同于：
str2 = "玫瑰是红色的\n紫罗兰是蓝色的"

# 在 Windows 系统，它可能等价于：
str3 = "玫瑰是红色的\r\n紫罗兰是蓝色的"

# 下列字符串的每一个字节都完全相同：
str1 = "那只 敏捷的 棕 狐狸 跳 过了 那只 懒 狗。"

str2 = """
那只 敏捷的 棕 \


  狐狸 跳 过了 \
    那只 懒 狗。"""

str3 = """\
       那只 敏捷的 棕 \
       狐狸 跳 过了 \
       那只 懒 狗。\
       """

# 所见即所得。
winpath  = 'C:\Users\nodejs\templates'
winpath2 = '\\ServerX\admin$\system32\'
quoted   = '汤姆·"达布斯"·普雷斯顿—维尔纳'
regex    = '<\i\c*\s*>'

regex2 = '''I [dw]on't need \d{2} apples'''
lines  = '''
原始字符串中的
第一个换行被剔除了。
   所有其它空白
   都保留了。
'''

int1 = +99
int2 = 42
int3 = 0
int4 = -17

int5 = 1_000
int6 = 5_349_221
int7 = 1_2_3_4_5     # 无误但不鼓励

# 带有 `0x` 前缀的十六进制
hex1 = 0xDEADBEEF
hex2 = 0xdeadbeef
hex3 = 0xdead_beef

# 带有 `0o` 前缀的八进制
oct1 = 0o01234567
oct2 = 0o755 # 对于表示 Unix 文件权限很有用

# 带有 `0b` 前缀的二进制
bin1 = 0b11010110

# 小数
flt1 = +1.0
flt2 = 3.1415
flt3 = -0.01

# 指数
flt4 = 5e+22
flt5 = 1e6
flt6 = -2E-2

# 都有
flt7 = 6.626e-34

flt8 = 224_617.445_991_228

# 无穷
sf1 = inf  # 正无穷
sf2 = +inf # 正无穷
sf3 = -inf # 负无穷

# 非数
sf4 = nan  # 实际上对应信号非数码还是静默非数码，取决于实现
sf5 = +nan # 等同于 `nan`
sf6 = -nan # 有效，实际码取决于实现

bool1 = true
bool2 = false

odt1 = 1979-05-27T07:32:00Z
odt2 = 1979-05-27T00:32:00-07:00
odt3 = 1979-05-27T00:32:00.999999-07:00

odt4 = 1979-05-27 07:32:00Z

ldt1 = 1979-05-27T07:32:00
ldt2 = 1979-05-27T00:32:00.999999

ld1 = 1979-05-27

lt1 = 07:32:00
lt2 = 00:32:00.999999

arr1 = [ 1, 2, 3 ]
arr2 = [ "red", "yellow", "green" ]
arr3 = [ [ 1, 2 ], [3, 4, 5] ]
arr4 = [ "所有（写法的）", '字符串', """都是一样的""", '''类型''']
arr5 = [ [ 1, 2 ], ["a", "b", "c"] ]

arr6 = [ 1, 2.0 ] # 有误

arr7 = [
  1, 2, 3
]

arr8 = [
  1,
  2, # 这是可以的
]

[table-1]
key1 = "some string"
key2 = 123

[table-2]
key1 = "another string"
key2 = 456

[dog."tater.man"]
type.name = "pug"

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

[a.b.c]            # 这是最佳实践
[ d.e.f ]          # 等同于 [d.e.f]
[ g .  h  . i ]    # 等同于 [g.h.i]
[ j . "ʞ" . 'l' ]  # 等同于 [j."ʞ".'l']

# [x] 你
# [x.y] 不
# [x.y.z] 需要这些
[x.y.z.w] # 来让这生效

# 不要这样做
[a]
b = 1

[a]
c = 2

# 也不要这样做
[a]
b = 1

[a.b]
c = 2

name = { first = "汤姆", last = "普雷斯顿—维尔纳" }
point = { x = 1, y = 2 }
animal = { type.name = "哈巴狗" }

# 上述行内表等同于下面的标准表定义

[name]
first = "汤姆"
last = "普雷斯顿—维尔纳"

[point]
x = 1
y = 2

[animal]
type.name = "哈巴狗"

[[products]]
name = "Hammer"
sku = 738594937

[[products]]

[[products]]
name = "Nail"
sku = 284758393
color = "gray"

{
  "products": [
    { "name": "Hammer", "sku": 738594937 },
    { },
    { "name": "Nail", "sku": 284758393, "color": "gray" }
  ]
}

[[fruit]]
  name = "apple"

  [fruit.physical]
    color = "red"
    shape = "round"

  [[fruit.variety]]
    name = "red delicious"

  [[fruit.variety]]
    name = "granny smith"

[[fruit]]
  name = "banana"

  [[fruit.variety]]
    name = "plantain"

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

# 无效的 TOML 文档
fruit = []

[[fruit]] # 不允许
若试图用已经确定为数组的名称定义表，必须在解析时报错。

# 无效的 TOML 文档
[[fruit]]
  name = "apple"

  [[fruit.variety]]
    name = "red delicious"

  # 这个表与之前的表冲突了
  [fruit.variety]
    name = "granny smith"

points = [ { x = 1, y = 2, z = 3 },
           { x = 7, y = 8, z = 9 },
           { x = 2, y = 4, z = 8 } ]

name = "UserProfileServer"
maxconns = 1000
queuecap = 10000
queuetimeout =300

[loginfo]
loglevel = "ERROR"
logsize = "10M"
lognum = 10
logpath = "/usr/local/app/log"

type Server struct {
	Name         string `toml:"name"`
	Maxconns     int    `toml:"maxconns"`
	Queuecap     int    `toml:"queuecap"`
	Queuetimeout int    `toml:"queuetimeout"`
	Loginfo      struct {
		Loglevel string `toml:"loglevel"`
		Logsize  string `toml:"logsize"`
		Lognum   int    `toml:"lognum"`
		Logpath  string `toml:"logpath"`
	} `toml:"loginfo"`
}

package main

import(
	"fmt"

	"github.com/BurntSushi/toml"
)

type Server struct {
	Name         string `toml:"name"`
	Maxconns     int    `toml:"maxconns"`
	Queuecap     int    `toml:"queuecap"`
	Queuetimeout int    `toml:"queuetimeout"`
	Loginfo      struct {
		Loglevel string `toml:"loglevel"`
		Logsize  string `toml:"logsize"`
		Lognum   int    `toml:"lognum"`
		Logpath  string `toml:"logpath"`
	} `toml:"loginfo"`
}

func main() {
  v := Server{}
  if _, err := toml.DecodeFile("server.toml", &v); err != nil {
	fmt.Printf("parse toml failed, err=%v\n", err)
  } else {
	 fmt.Printf("%+v\n", v)
  } 
}

{Name:UserProfileServer Maxconns:1000 Queuecap:10000 Queuetimeout:300 Loginfo:{Loglevel:ERROR Logsize:10M Lognum:10 Logpath:/usr/local/app/log}}

<tars>
  <application>
    enableset=n
    <server>
       node=tars.tarsnode.ServerObj@tcp -h 10.120.129.226 -p 19386 -t 60000
       app=TestApp
       server=HelloServer
       localip=10.120.129.226
    </server>
    <client>
       locator=tars.tarsregistry.QueryObj@tcp -h 10.120.129.226 -p 17890
       sync-invoke-timeout=3000
    </client>
  </application>
</tars>