读取带注释JSON配置文件-GO语言讲解

Copycopy code to clipboard
1{
2  "url": "https://www.swordman.xyz",
3  "authors": [
4    "yeluo",
5    "qiuzhi"
6  ], //尾后逗号与注释
7}

Copycopy code to clipboard
1Uncaught SyntaxError: Unexpected token / in JSON at position 81

Copycopy code to clipboard
1package main
2
3import (
4    "encoding/json"
5    "fmt"
6    "strings"
7
8    "github.com/DisposaBoy/JsonConfigReader"
9)
10
11func main() {
12    var v interface{}
13    str := strings.NewReader(`
14        {
15            "url": "https://www.reim.xyz",
16            "authors": [
17                "yeluo",
18                "qiuzhi"
19            ], //尾后逗号与注释
20        }
21    `)
22    // wrap our reader before passing it to the json decoder
23    r := JsonConfigReader.New(str)
24    json.NewDecoder(r).Decode(&v)
25    fmt.Println(v)
26}
27// output: map[authors:[yeluo qiuzhi] url:https://www.reim.xyz]

Copycopy code to clipboard
1// 识别换行符
2func isNL(c byte) bool {
3    return c == '\n' || c == '\r'
4}

Copycopy code to clipboard
1// 识别空格与制表符
2func isWS(c byte) bool {
3    return c == ' ' || c == '\t' || isNL(c)
4}

Copycopy code to clipboard
1// 把s变量中的注释、尾后逗号替换成空格
2// 替换成空格相比删除不合法内容更容易实现且性能损耗低
3func prep(r io.Reader) (s []byte, err error) {
4    buf := &bytes.Buffer{}
5    // 复制原始数据
6    _, err = io.Copy(buf, r)
7    s = buf.Bytes()
8    if err != nil {
9        return
10    }
11
12    i := 0
13    // 遍历全部字符
14    for i < len(s) {
15        switch s[i] {
16        // 遇到字符串开始标志, 开启内部循环跳过
17        case '"':
18            i += 1
19            for i < len(s) {
20                // 遇到字符串结束标志，退出内部循环
21                if s[i] == '"' {
22                    i += 1
23                    break
24                // 忽略字符串转义
25                // 两次 i += 1 等于 i += 2
26                // 跳过\与紧接着\的第一个字符
27                } else if s[i] == '\\' {
28                    i += 1
29                }
30                i += 1
31            }
32        // 可能是注释开始标志，执行转交给注释处理程序
33        case '/':
34            i = consumeComment(s, i+1)
35        // 可能是尾后逗号，处理尾后逗号
36        case ',':
37            // 记录逗号位置
38            j := i
39            // 开始内部循环，跳过空格、制表符与注释
40            for {
41                i += 1
42                if i >= len(s) {
43                    break
44                // 下一个合法字符是数组或对象结束标志
45                // 把记录下来的尾后逗号替换成空格
46                } else if s[i] == '}' || s[i] == ']' {
47                    s[j] = ' '
48                    break
49                // 可能是注释开始标志，执行转交给注释处理程序
50                } else if s[i] == '/' {
51                    i = consumeComment(s, i+1)
52                } else if !isWS(s[i]) {
53                    break
54                }
55            }
56        // 其它情况不需要处理，直接跳过该字符
57        default:
58            i += 1
59        }
60    }
61    return
62}

Copycopy code to clipboard
1// 接下来的内容如果是注释，则全部替换成空格,
2// 不是注释则不做任何处理
3// 返回处理结束后下标所在位置
4func consumeComment(s []byte, i int) int {
5    // 如果遇到行内注释, 从 "//" 到行结束全部换成空格
6    if i < len(s) && s[i] == '/' {
7        s[i-1] = ' '
8        for ; i < len(s) && !isNL(s[i]); i += 1 {
9            s[i] = ' '
10        }
11    }
12    // 如果遇到块级注释, 从"/*"到"*/"全部换成空格
13    if i < len(s) && s[i] == '*' {
14        s[i-1] = ' '
15        s[i] = ' '
16        for ; i < len(s); i += 1 {
17            // 不是*全部换成空格
18            if s[i] != '*' {
19                s[i] = ' '
20            // 遇到*
21            } else {
22                s[i] = ' '
23                // 移动到下一字符
24                i++
25                if i < len(s) {
26                    // *后面是/, 即"*/",跳出循环
27                    if s[i] == '/' {
28                        s[i] = ' '
29                        break
30                    }
31                }
32            }
33        }
34    }
35    return i
36}

Copycopy code to clipboard
1// 创建state结构
2type state struct {
3    r  io.Reader
4    br *bytes.Reader
5}
6// 为state结构实现io.Reader接口
7func (st *state) Read(p []byte) (n int, err error) {
8    // 第一次读取时才处理数据，节省不必要性能开支
9    if st.br == nil {
10        var s []byte
11        if s, err = prep(st.r); err != nil {
12            return
13        }
14        st.br = bytes.NewReader(s)
15    }
16    return st.br.Read(p)
17}
18
19// 创建一个实现了io.Reader接口的state结构对象, 作为原始Reader的代理
20func New(r io.Reader) io.Reader {
21    return &state{r: r}
22}