]>
Commit | Line | Data |
---|---|---|
bae9f6d2 JC |
1 | 本包提供了 Go 语言中读写 INI 文件的功能。 |
2 | ||
3 | ## 功能特性 | |
4 | ||
5 | - 支持覆盖加载多个数据源(`[]byte`、文件和 `io.ReadCloser`) | |
6 | - 支持递归读取键值 | |
7 | - 支持读取父子分区 | |
8 | - 支持读取自增键名 | |
9 | - 支持读取多行的键值 | |
10 | - 支持大量辅助方法 | |
11 | - 支持在读取时直接转换为 Go 语言类型 | |
12 | - 支持读取和 **写入** 分区和键的注释 | |
13 | - 轻松操作分区、键值和注释 | |
14 | - 在保存文件时分区和键值会保持原有的顺序 | |
15 | ||
16 | ## 下载安装 | |
17 | ||
18 | 使用一个特定版本: | |
19 | ||
20 | go get gopkg.in/ini.v1 | |
21 | ||
22 | 使用最新版: | |
23 | ||
24 | go get github.com/go-ini/ini | |
25 | ||
26 | 如需更新请添加 `-u` 选项。 | |
27 | ||
28 | ### 测试安装 | |
29 | ||
30 | 如果您想要在自己的机器上运行测试,请使用 `-t` 标记: | |
31 | ||
32 | go get -t gopkg.in/ini.v1 | |
33 | ||
34 | 如需更新请添加 `-u` 选项。 | |
35 | ||
36 | ## 开始使用 | |
37 | ||
38 | ### 从数据源加载 | |
39 | ||
40 | 一个 **数据源** 可以是 `[]byte` 类型的原始数据,`string` 类型的文件路径或 `io.ReadCloser`。您可以加载 **任意多个** 数据源。如果您传递其它类型的数据源,则会直接返回错误。 | |
41 | ||
42 | ```go | |
43 | cfg, err := ini.Load([]byte("raw data"), "filename", ioutil.NopCloser(bytes.NewReader([]byte("some other data")))) | |
44 | ``` | |
45 | ||
46 | 或者从一个空白的文件开始: | |
47 | ||
48 | ```go | |
49 | cfg := ini.Empty() | |
50 | ``` | |
51 | ||
52 | 当您在一开始无法决定需要加载哪些数据源时,仍可以使用 **Append()** 在需要的时候加载它们。 | |
53 | ||
54 | ```go | |
55 | err := cfg.Append("other file", []byte("other raw data")) | |
56 | ``` | |
57 | ||
58 | 当您想要加载一系列文件,但是不能够确定其中哪些文件是不存在的,可以通过调用函数 `LooseLoad` 来忽略它们(`Load` 会因为文件不存在而返回错误): | |
59 | ||
60 | ```go | |
61 | cfg, err := ini.LooseLoad("filename", "filename_404") | |
62 | ``` | |
63 | ||
64 | 更牛逼的是,当那些之前不存在的文件在重新调用 `Reload` 方法的时候突然出现了,那么它们会被正常加载。 | |
65 | ||
66 | #### 忽略键名的大小写 | |
67 | ||
68 | 有时候分区和键的名称大小写混合非常烦人,这个时候就可以通过 `InsensitiveLoad` 将所有分区和键名在读取里强制转换为小写: | |
69 | ||
70 | ```go | |
71 | cfg, err := ini.InsensitiveLoad("filename") | |
72 | //... | |
73 | ||
74 | // sec1 和 sec2 指向同一个分区对象 | |
75 | sec1, err := cfg.GetSection("Section") | |
76 | sec2, err := cfg.GetSection("SecTIOn") | |
77 | ||
78 | // key1 和 key2 指向同一个键对象 | |
79 | key1, err := cfg.GetKey("Key") | |
80 | key2, err := cfg.GetKey("KeY") | |
81 | ``` | |
82 | ||
83 | #### 类似 MySQL 配置中的布尔值键 | |
84 | ||
85 | MySQL 的配置文件中会出现没有具体值的布尔类型的键: | |
86 | ||
87 | ```ini | |
88 | [mysqld] | |
89 | ... | |
90 | skip-host-cache | |
91 | skip-name-resolve | |
92 | ``` | |
93 | ||
94 | 默认情况下这被认为是缺失值而无法完成解析,但可以通过高级的加载选项对它们进行处理: | |
95 | ||
96 | ```go | |
97 | cfg, err := LoadSources(LoadOptions{AllowBooleanKeys: true}, "my.cnf")) | |
98 | ``` | |
99 | ||
100 | 这些键的值永远为 `true`,且在保存到文件时也只会输出键名。 | |
101 | ||
15c0b25d AP |
102 | 如果您想要通过程序来生成此类键,则可以使用 `NewBooleanKey`: |
103 | ||
104 | ```go | |
105 | key, err := sec.NewBooleanKey("skip-host-cache") | |
106 | ``` | |
107 | ||
bae9f6d2 JC |
108 | #### 关于注释 |
109 | ||
110 | 下述几种情况的内容将被视为注释: | |
111 | ||
112 | 1. 所有以 `#` 或 `;` 开头的行 | |
113 | 2. 所有在 `#` 或 `;` 之后的内容 | |
114 | 3. 分区标签后的文字 (即 `[分区名]` 之后的内容) | |
115 | ||
116 | 如果你希望使用包含 `#` 或 `;` 的值,请使用 ``` ` ``` 或 ``` """ ``` 进行包覆。 | |
117 | ||
118 | ### 操作分区(Section) | |
119 | ||
120 | 获取指定分区: | |
121 | ||
122 | ```go | |
123 | section, err := cfg.GetSection("section name") | |
124 | ``` | |
125 | ||
126 | 如果您想要获取默认分区,则可以用空字符串代替分区名: | |
127 | ||
128 | ```go | |
129 | section, err := cfg.GetSection("") | |
130 | ``` | |
131 | ||
132 | 当您非常确定某个分区是存在的,可以使用以下简便方法: | |
133 | ||
134 | ```go | |
135 | section := cfg.Section("section name") | |
136 | ``` | |
137 | ||
138 | 如果不小心判断错了,要获取的分区其实是不存在的,那会发生什么呢?没事的,它会自动创建并返回一个对应的分区对象给您。 | |
139 | ||
140 | 创建一个分区: | |
141 | ||
142 | ```go | |
143 | err := cfg.NewSection("new section") | |
144 | ``` | |
145 | ||
146 | 获取所有分区对象或名称: | |
147 | ||
148 | ```go | |
149 | sections := cfg.Sections() | |
150 | names := cfg.SectionStrings() | |
151 | ``` | |
152 | ||
153 | ### 操作键(Key) | |
154 | ||
155 | 获取某个分区下的键: | |
156 | ||
157 | ```go | |
158 | key, err := cfg.Section("").GetKey("key name") | |
159 | ``` | |
160 | ||
161 | 和分区一样,您也可以直接获取键而忽略错误处理: | |
162 | ||
163 | ```go | |
164 | key := cfg.Section("").Key("key name") | |
165 | ``` | |
166 | ||
167 | 判断某个键是否存在: | |
168 | ||
169 | ```go | |
170 | yes := cfg.Section("").HasKey("key name") | |
171 | ``` | |
172 | ||
173 | 创建一个新的键: | |
174 | ||
175 | ```go | |
176 | err := cfg.Section("").NewKey("name", "value") | |
177 | ``` | |
178 | ||
179 | 获取分区下的所有键或键名: | |
180 | ||
181 | ```go | |
182 | keys := cfg.Section("").Keys() | |
183 | names := cfg.Section("").KeyStrings() | |
184 | ``` | |
185 | ||
186 | 获取分区下的所有键值对的克隆: | |
187 | ||
188 | ```go | |
189 | hash := cfg.Section("").KeysHash() | |
190 | ``` | |
191 | ||
192 | ### 操作键值(Value) | |
193 | ||
194 | 获取一个类型为字符串(string)的值: | |
195 | ||
196 | ```go | |
197 | val := cfg.Section("").Key("key name").String() | |
198 | ``` | |
199 | ||
200 | 获取值的同时通过自定义函数进行处理验证: | |
201 | ||
202 | ```go | |
203 | val := cfg.Section("").Key("key name").Validate(func(in string) string { | |
204 | if len(in) == 0 { | |
205 | return "default" | |
206 | } | |
207 | return in | |
208 | }) | |
209 | ``` | |
210 | ||
211 | 如果您不需要任何对值的自动转变功能(例如递归读取),可以直接获取原值(这种方式性能最佳): | |
212 | ||
213 | ```go | |
214 | val := cfg.Section("").Key("key name").Value() | |
215 | ``` | |
216 | ||
217 | 判断某个原值是否存在: | |
218 | ||
219 | ```go | |
220 | yes := cfg.Section("").HasValue("test value") | |
221 | ``` | |
222 | ||
223 | 获取其它类型的值: | |
224 | ||
225 | ```go | |
226 | // 布尔值的规则: | |
227 | // true 当值为:1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On | |
228 | // false 当值为:0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off | |
229 | v, err = cfg.Section("").Key("BOOL").Bool() | |
230 | v, err = cfg.Section("").Key("FLOAT64").Float64() | |
231 | v, err = cfg.Section("").Key("INT").Int() | |
232 | v, err = cfg.Section("").Key("INT64").Int64() | |
233 | v, err = cfg.Section("").Key("UINT").Uint() | |
234 | v, err = cfg.Section("").Key("UINT64").Uint64() | |
235 | v, err = cfg.Section("").Key("TIME").TimeFormat(time.RFC3339) | |
236 | v, err = cfg.Section("").Key("TIME").Time() // RFC3339 | |
237 | ||
238 | v = cfg.Section("").Key("BOOL").MustBool() | |
239 | v = cfg.Section("").Key("FLOAT64").MustFloat64() | |
240 | v = cfg.Section("").Key("INT").MustInt() | |
241 | v = cfg.Section("").Key("INT64").MustInt64() | |
242 | v = cfg.Section("").Key("UINT").MustUint() | |
243 | v = cfg.Section("").Key("UINT64").MustUint64() | |
244 | v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339) | |
245 | v = cfg.Section("").Key("TIME").MustTime() // RFC3339 | |
246 | ||
247 | // 由 Must 开头的方法名允许接收一个相同类型的参数来作为默认值, | |
248 | // 当键不存在或者转换失败时,则会直接返回该默认值。 | |
249 | // 但是,MustString 方法必须传递一个默认值。 | |
250 | ||
251 | v = cfg.Seciont("").Key("String").MustString("default") | |
252 | v = cfg.Section("").Key("BOOL").MustBool(true) | |
253 | v = cfg.Section("").Key("FLOAT64").MustFloat64(1.25) | |
254 | v = cfg.Section("").Key("INT").MustInt(10) | |
255 | v = cfg.Section("").Key("INT64").MustInt64(99) | |
256 | v = cfg.Section("").Key("UINT").MustUint(3) | |
257 | v = cfg.Section("").Key("UINT64").MustUint64(6) | |
258 | v = cfg.Section("").Key("TIME").MustTimeFormat(time.RFC3339, time.Now()) | |
259 | v = cfg.Section("").Key("TIME").MustTime(time.Now()) // RFC3339 | |
260 | ``` | |
261 | ||
262 | 如果我的值有好多行怎么办? | |
263 | ||
264 | ```ini | |
265 | [advance] | |
266 | ADDRESS = """404 road, | |
267 | NotFound, State, 5000 | |
268 | Earth""" | |
269 | ``` | |
270 | ||
271 | 嗯哼?小 case! | |
272 | ||
273 | ```go | |
274 | cfg.Section("advance").Key("ADDRESS").String() | |
275 | ||
276 | /* --- start --- | |
277 | 404 road, | |
278 | NotFound, State, 5000 | |
279 | Earth | |
280 | ------ end --- */ | |
281 | ``` | |
282 | ||
283 | 赞爆了!那要是我属于一行的内容写不下想要写到第二行怎么办? | |
284 | ||
285 | ```ini | |
286 | [advance] | |
287 | two_lines = how about \ | |
288 | continuation lines? | |
289 | lots_of_lines = 1 \ | |
290 | 2 \ | |
291 | 3 \ | |
292 | 4 | |
293 | ``` | |
294 | ||
295 | 简直是小菜一碟! | |
296 | ||
297 | ```go | |
298 | cfg.Section("advance").Key("two_lines").String() // how about continuation lines? | |
299 | cfg.Section("advance").Key("lots_of_lines").String() // 1 2 3 4 | |
300 | ``` | |
301 | ||
302 | 可是我有时候觉得两行连在一起特别没劲,怎么才能不自动连接两行呢? | |
303 | ||
304 | ```go | |
305 | cfg, err := ini.LoadSources(ini.LoadOptions{ | |
306 | IgnoreContinuation: true, | |
307 | }, "filename") | |
308 | ``` | |
309 | ||
310 | 哇靠给力啊! | |
311 | ||
312 | 需要注意的是,值两侧的单引号会被自动剔除: | |
313 | ||
314 | ```ini | |
315 | foo = "some value" // foo: some value | |
316 | bar = 'some value' // bar: some value | |
317 | ``` | |
318 | ||
319 | 这就是全部了?哈哈,当然不是。 | |
320 | ||
321 | #### 操作键值的辅助方法 | |
322 | ||
323 | 获取键值时设定候选值: | |
324 | ||
325 | ```go | |
326 | v = cfg.Section("").Key("STRING").In("default", []string{"str", "arr", "types"}) | |
327 | v = cfg.Section("").Key("FLOAT64").InFloat64(1.1, []float64{1.25, 2.5, 3.75}) | |
328 | v = cfg.Section("").Key("INT").InInt(5, []int{10, 20, 30}) | |
329 | v = cfg.Section("").Key("INT64").InInt64(10, []int64{10, 20, 30}) | |
330 | v = cfg.Section("").Key("UINT").InUint(4, []int{3, 6, 9}) | |
331 | v = cfg.Section("").Key("UINT64").InUint64(8, []int64{3, 6, 9}) | |
332 | v = cfg.Section("").Key("TIME").InTimeFormat(time.RFC3339, time.Now(), []time.Time{time1, time2, time3}) | |
333 | v = cfg.Section("").Key("TIME").InTime(time.Now(), []time.Time{time1, time2, time3}) // RFC3339 | |
334 | ``` | |
335 | ||
336 | 如果获取到的值不是候选值的任意一个,则会返回默认值,而默认值不需要是候选值中的一员。 | |
337 | ||
338 | 验证获取的值是否在指定范围内: | |
339 | ||
340 | ```go | |
341 | vals = cfg.Section("").Key("FLOAT64").RangeFloat64(0.0, 1.1, 2.2) | |
342 | vals = cfg.Section("").Key("INT").RangeInt(0, 10, 20) | |
343 | vals = cfg.Section("").Key("INT64").RangeInt64(0, 10, 20) | |
344 | vals = cfg.Section("").Key("UINT").RangeUint(0, 3, 9) | |
345 | vals = cfg.Section("").Key("UINT64").RangeUint64(0, 3, 9) | |
346 | vals = cfg.Section("").Key("TIME").RangeTimeFormat(time.RFC3339, time.Now(), minTime, maxTime) | |
347 | vals = cfg.Section("").Key("TIME").RangeTime(time.Now(), minTime, maxTime) // RFC3339 | |
348 | ``` | |
349 | ||
350 | ##### 自动分割键值到切片(slice) | |
351 | ||
352 | 当存在无效输入时,使用零值代替: | |
353 | ||
354 | ```go | |
355 | // Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4] | |
356 | // Input: how, 2.2, are, you -> [0.0 2.2 0.0 0.0] | |
357 | vals = cfg.Section("").Key("STRINGS").Strings(",") | |
358 | vals = cfg.Section("").Key("FLOAT64S").Float64s(",") | |
359 | vals = cfg.Section("").Key("INTS").Ints(",") | |
360 | vals = cfg.Section("").Key("INT64S").Int64s(",") | |
361 | vals = cfg.Section("").Key("UINTS").Uints(",") | |
362 | vals = cfg.Section("").Key("UINT64S").Uint64s(",") | |
363 | vals = cfg.Section("").Key("TIMES").Times(",") | |
364 | ``` | |
365 | ||
366 | 从结果切片中剔除无效输入: | |
367 | ||
368 | ```go | |
369 | // Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4] | |
370 | // Input: how, 2.2, are, you -> [2.2] | |
371 | vals = cfg.Section("").Key("FLOAT64S").ValidFloat64s(",") | |
372 | vals = cfg.Section("").Key("INTS").ValidInts(",") | |
373 | vals = cfg.Section("").Key("INT64S").ValidInt64s(",") | |
374 | vals = cfg.Section("").Key("UINTS").ValidUints(",") | |
375 | vals = cfg.Section("").Key("UINT64S").ValidUint64s(",") | |
376 | vals = cfg.Section("").Key("TIMES").ValidTimes(",") | |
377 | ``` | |
378 | ||
379 | 当存在无效输入时,直接返回错误: | |
380 | ||
381 | ```go | |
382 | // Input: 1.1, 2.2, 3.3, 4.4 -> [1.1 2.2 3.3 4.4] | |
383 | // Input: how, 2.2, are, you -> error | |
384 | vals = cfg.Section("").Key("FLOAT64S").StrictFloat64s(",") | |
385 | vals = cfg.Section("").Key("INTS").StrictInts(",") | |
386 | vals = cfg.Section("").Key("INT64S").StrictInt64s(",") | |
387 | vals = cfg.Section("").Key("UINTS").StrictUints(",") | |
388 | vals = cfg.Section("").Key("UINT64S").StrictUint64s(",") | |
389 | vals = cfg.Section("").Key("TIMES").StrictTimes(",") | |
390 | ``` | |
391 | ||
392 | ### 保存配置 | |
393 | ||
394 | 终于到了这个时刻,是时候保存一下配置了。 | |
395 | ||
396 | 比较原始的做法是输出配置到某个文件: | |
397 | ||
398 | ```go | |
399 | // ... | |
400 | err = cfg.SaveTo("my.ini") | |
401 | err = cfg.SaveToIndent("my.ini", "\t") | |
402 | ``` | |
403 | ||
404 | 另一个比较高级的做法是写入到任何实现 `io.Writer` 接口的对象中: | |
405 | ||
406 | ```go | |
407 | // ... | |
408 | cfg.WriteTo(writer) | |
409 | cfg.WriteToIndent(writer, "\t") | |
410 | ``` | |
411 | ||
412 | 默认情况下,空格将被用于对齐键值之间的等号以美化输出结果,以下代码可以禁用该功能: | |
413 | ||
414 | ```go | |
415 | ini.PrettyFormat = false | |
416 | ``` | |
417 | ||
418 | ## 高级用法 | |
419 | ||
420 | ### 递归读取键值 | |
421 | ||
422 | 在获取所有键值的过程中,特殊语法 `%(<name>)s` 会被应用,其中 `<name>` 可以是相同分区或者默认分区下的键名。字符串 `%(<name>)s` 会被相应的键值所替代,如果指定的键不存在,则会用空字符串替代。您可以最多使用 99 层的递归嵌套。 | |
423 | ||
424 | ```ini | |
425 | NAME = ini | |
426 | ||
427 | [author] | |
428 | NAME = Unknwon | |
429 | GITHUB = https://github.com/%(NAME)s | |
430 | ||
431 | [package] | |
432 | FULL_NAME = github.com/go-ini/%(NAME)s | |
433 | ``` | |
434 | ||
435 | ```go | |
436 | cfg.Section("author").Key("GITHUB").String() // https://github.com/Unknwon | |
437 | cfg.Section("package").Key("FULL_NAME").String() // github.com/go-ini/ini | |
438 | ``` | |
439 | ||
440 | ### 读取父子分区 | |
441 | ||
442 | 您可以在分区名称中使用 `.` 来表示两个或多个分区之间的父子关系。如果某个键在子分区中不存在,则会去它的父分区中再次寻找,直到没有父分区为止。 | |
443 | ||
444 | ```ini | |
445 | NAME = ini | |
446 | VERSION = v1 | |
447 | IMPORT_PATH = gopkg.in/%(NAME)s.%(VERSION)s | |
448 | ||
449 | [package] | |
450 | CLONE_URL = https://%(IMPORT_PATH)s | |
451 | ||
452 | [package.sub] | |
453 | ``` | |
454 | ||
455 | ```go | |
456 | cfg.Section("package.sub").Key("CLONE_URL").String() // https://gopkg.in/ini.v1 | |
457 | ``` | |
458 | ||
459 | #### 获取上级父分区下的所有键名 | |
460 | ||
461 | ```go | |
462 | cfg.Section("package.sub").ParentKeys() // ["CLONE_URL"] | |
463 | ``` | |
464 | ||
465 | ### 无法解析的分区 | |
466 | ||
467 | 如果遇到一些比较特殊的分区,它们不包含常见的键值对,而是没有固定格式的纯文本,则可以使用 `LoadOptions.UnparsableSections` 进行处理: | |
468 | ||
469 | ```go | |
470 | cfg, err := LoadSources(LoadOptions{UnparseableSections: []string{"COMMENTS"}}, `[COMMENTS] | |
471 | <1><L.Slide#2> This slide has the fuel listed in the wrong units <e.1>`)) | |
472 | ||
473 | body := cfg.Section("COMMENTS").Body() | |
474 | ||
475 | /* --- start --- | |
476 | <1><L.Slide#2> This slide has the fuel listed in the wrong units <e.1> | |
477 | ------ end --- */ | |
478 | ``` | |
479 | ||
480 | ### 读取自增键名 | |
481 | ||
482 | 如果数据源中的键名为 `-`,则认为该键使用了自增键名的特殊语法。计数器从 1 开始,并且分区之间是相互独立的。 | |
483 | ||
484 | ```ini | |
485 | [features] | |
486 | -: Support read/write comments of keys and sections | |
487 | -: Support auto-increment of key names | |
488 | -: Support load multiple files to overwrite key values | |
489 | ``` | |
490 | ||
491 | ```go | |
492 | cfg.Section("features").KeyStrings() // []{"#1", "#2", "#3"} | |
493 | ``` | |
494 | ||
495 | ### 映射到结构 | |
496 | ||
497 | 想要使用更加面向对象的方式玩转 INI 吗?好主意。 | |
498 | ||
499 | ```ini | |
500 | Name = Unknwon | |
501 | age = 21 | |
502 | Male = true | |
503 | Born = 1993-01-01T20:17:05Z | |
504 | ||
505 | [Note] | |
506 | Content = Hi is a good man! | |
507 | Cities = HangZhou, Boston | |
508 | ``` | |
509 | ||
510 | ```go | |
511 | type Note struct { | |
512 | Content string | |
513 | Cities []string | |
514 | } | |
515 | ||
516 | type Person struct { | |
517 | Name string | |
518 | Age int `ini:"age"` | |
519 | Male bool | |
520 | Born time.Time | |
521 | Note | |
522 | Created time.Time `ini:"-"` | |
523 | } | |
524 | ||
525 | func main() { | |
526 | cfg, err := ini.Load("path/to/ini") | |
527 | // ... | |
528 | p := new(Person) | |
529 | err = cfg.MapTo(p) | |
530 | // ... | |
531 | ||
532 | // 一切竟可以如此的简单。 | |
533 | err = ini.MapTo(p, "path/to/ini") | |
534 | // ... | |
535 | ||
536 | // 嗯哼?只需要映射一个分区吗? | |
537 | n := new(Note) | |
538 | err = cfg.Section("Note").MapTo(n) | |
539 | // ... | |
540 | } | |
541 | ``` | |
542 | ||
543 | 结构的字段怎么设置默认值呢?很简单,只要在映射之前对指定字段进行赋值就可以了。如果键未找到或者类型错误,该值不会发生改变。 | |
544 | ||
545 | ```go | |
546 | // ... | |
547 | p := &Person{ | |
548 | Name: "Joe", | |
549 | } | |
550 | // ... | |
551 | ``` | |
552 | ||
553 | 这样玩 INI 真的好酷啊!然而,如果不能还给我原来的配置文件,有什么卵用? | |
554 | ||
555 | ### 从结构反射 | |
556 | ||
557 | 可是,我有说不能吗? | |
558 | ||
559 | ```go | |
560 | type Embeded struct { | |
561 | Dates []time.Time `delim:"|"` | |
562 | Places []string `ini:"places,omitempty"` | |
563 | None []int `ini:",omitempty"` | |
564 | } | |
565 | ||
566 | type Author struct { | |
567 | Name string `ini:"NAME"` | |
568 | Male bool | |
569 | Age int | |
570 | GPA float64 | |
571 | NeverMind string `ini:"-"` | |
572 | *Embeded | |
573 | } | |
574 | ||
575 | func main() { | |
576 | a := &Author{"Unknwon", true, 21, 2.8, "", | |
577 | &Embeded{ | |
578 | []time.Time{time.Now(), time.Now()}, | |
579 | []string{"HangZhou", "Boston"}, | |
580 | []int{}, | |
581 | }} | |
582 | cfg := ini.Empty() | |
583 | err = ini.ReflectFrom(cfg, a) | |
584 | // ... | |
585 | } | |
586 | ``` | |
587 | ||
588 | 瞧瞧,奇迹发生了。 | |
589 | ||
590 | ```ini | |
591 | NAME = Unknwon | |
592 | Male = true | |
593 | Age = 21 | |
594 | GPA = 2.8 | |
595 | ||
596 | [Embeded] | |
597 | Dates = 2015-08-07T22:14:22+08:00|2015-08-07T22:14:22+08:00 | |
598 | places = HangZhou,Boston | |
599 | ``` | |
600 | ||
601 | #### 名称映射器(Name Mapper) | |
602 | ||
603 | 为了节省您的时间并简化代码,本库支持类型为 [`NameMapper`](https://gowalker.org/gopkg.in/ini.v1#NameMapper) 的名称映射器,该映射器负责结构字段名与分区名和键名之间的映射。 | |
604 | ||
605 | 目前有 2 款内置的映射器: | |
606 | ||
607 | - `AllCapsUnderscore`:该映射器将字段名转换至格式 `ALL_CAPS_UNDERSCORE` 后再去匹配分区名和键名。 | |
608 | - `TitleUnderscore`:该映射器将字段名转换至格式 `title_underscore` 后再去匹配分区名和键名。 | |
609 | ||
610 | 使用方法: | |
611 | ||
612 | ```go | |
613 | type Info struct{ | |
614 | PackageName string | |
615 | } | |
616 | ||
617 | func main() { | |
618 | err = ini.MapToWithMapper(&Info{}, ini.TitleUnderscore, []byte("package_name=ini")) | |
619 | // ... | |
620 | ||
621 | cfg, err := ini.Load([]byte("PACKAGE_NAME=ini")) | |
622 | // ... | |
623 | info := new(Info) | |
624 | cfg.NameMapper = ini.AllCapsUnderscore | |
625 | err = cfg.MapTo(info) | |
626 | // ... | |
627 | } | |
628 | ``` | |
629 | ||
630 | 使用函数 `ini.ReflectFromWithMapper` 时也可应用相同的规则。 | |
631 | ||
632 | #### 值映射器(Value Mapper) | |
633 | ||
634 | 值映射器允许使用一个自定义函数自动展开值的具体内容,例如:运行时获取环境变量: | |
635 | ||
636 | ```go | |
637 | type Env struct { | |
638 | Foo string `ini:"foo"` | |
639 | } | |
640 | ||
641 | func main() { | |
642 | cfg, err := ini.Load([]byte("[env]\nfoo = ${MY_VAR}\n") | |
643 | cfg.ValueMapper = os.ExpandEnv | |
644 | // ... | |
645 | env := &Env{} | |
646 | err = cfg.Section("env").MapTo(env) | |
647 | } | |
648 | ``` | |
649 | ||
650 | 本例中,`env.Foo` 将会是运行时所获取到环境变量 `MY_VAR` 的值。 | |
651 | ||
652 | #### 映射/反射的其它说明 | |
653 | ||
654 | 任何嵌入的结构都会被默认认作一个不同的分区,并且不会自动产生所谓的父子分区关联: | |
655 | ||
656 | ```go | |
657 | type Child struct { | |
658 | Age string | |
659 | } | |
660 | ||
661 | type Parent struct { | |
662 | Name string | |
663 | Child | |
664 | } | |
665 | ||
666 | type Config struct { | |
667 | City string | |
668 | Parent | |
669 | } | |
670 | ``` | |
671 | ||
672 | 示例配置文件: | |
673 | ||
674 | ```ini | |
675 | City = Boston | |
676 | ||
677 | [Parent] | |
678 | Name = Unknwon | |
679 | ||
680 | [Child] | |
681 | Age = 21 | |
682 | ``` | |
683 | ||
684 | 很好,但是,我就是要嵌入结构也在同一个分区。好吧,你爹是李刚! | |
685 | ||
686 | ```go | |
687 | type Child struct { | |
688 | Age string | |
689 | } | |
690 | ||
691 | type Parent struct { | |
692 | Name string | |
693 | Child `ini:"Parent"` | |
694 | } | |
695 | ||
696 | type Config struct { | |
697 | City string | |
698 | Parent | |
699 | } | |
700 | ``` | |
701 | ||
702 | 示例配置文件: | |
703 | ||
704 | ```ini | |
705 | City = Boston | |
706 | ||
707 | [Parent] | |
708 | Name = Unknwon | |
709 | Age = 21 | |
710 | ``` | |
711 | ||
712 | ## 获取帮助 | |
713 | ||
714 | - [API 文档](https://gowalker.org/gopkg.in/ini.v1) | |
715 | - [创建工单](https://github.com/go-ini/ini/issues/new) | |
716 | ||
717 | ## 常见问题 | |
718 | ||
719 | ### 字段 `BlockMode` 是什么? | |
720 | ||
721 | 默认情况下,本库会在您进行读写操作时采用锁机制来确保数据时间。但在某些情况下,您非常确定只进行读操作。此时,您可以通过设置 `cfg.BlockMode = false` 来将读操作提升大约 **50-70%** 的性能。 | |
722 | ||
723 | ### 为什么要写另一个 INI 解析库? | |
724 | ||
725 | 许多人都在使用我的 [goconfig](https://github.com/Unknwon/goconfig) 来完成对 INI 文件的操作,但我希望使用更加 Go 风格的代码。并且当您设置 `cfg.BlockMode = false` 时,会有大约 **10-30%** 的性能提升。 | |
726 | ||
727 | 为了做出这些改变,我必须对 API 进行破坏,所以新开一个仓库是最安全的做法。除此之外,本库直接使用 `gopkg.in` 来进行版本化发布。(其实真相是导入路径更短了) |