Go处理json数据

json数据格式

参见。

如果没操作过json数据，建议先看下上面的文章，有助于理解本文后面的内容。

go json包

marshal()：go数据对象 -> json数据
unmarshal()：json数据 -> go数据对象

func marshal(v interface{}) ([]byte, error)
func unmarshal(data []byte, v interface{}) error

构建json数据

marshal()和marshalindent()函数可以将数据封装成json数据。

• struct、slice、array、map都可以转换成json
  
• struct转换成json的时候，只有字段首字母大写的才会被转换
  
• map转换的时候，key必须为string
  
• 封装的时候，如果是指针，会追踪指针指向的对象进行封装

例如：

有一个struct结构：

type post struct {
    id      int
    content string
    author  string
}

这个结构表示博客文章类型，有文章id，文章内容，文章的提交作者。这没什么可说的，唯一需要指明的是：它是一个struct，struct可以封装(编码)成json数据。

要将这段struct数据转换成json，只需使用marshal()即可。如下：

post := &post{1, "hello world", "usera"}
b, err := json.marshal(post)
if err != nil {
    fmt.println(nil)
}

marshal()返回的是一个[]byte类型，现在变量b就已经存储了一段[]byte类型的json数据，可以输出它：

fmt.println(string(b))

结果：

{"id":1,"content":"hello world","author":"usera"}

可以在封装成json的时候进行"美化"，使用marshalindent()即可自动添加前缀(前缀字符串一般设置为空)和缩进：

c,err := json.marshalindent(post,"","\t")
if err != nil {
    fmt.println(nil)
}
fmt.println(string(c))

结果：

{
    "id": 1,
    "content": "hello world",
    "author": "usera"
}

除了struct，array、slice、map结构都能解析成json，但是map解析成json的时候，key必须只能是string，这是json语法要求的。

例如：

// slice -> json
s := []string{"a", "b", "c"}
d, _ := json.marshalindent(s, "", "\t")
fmt.println(string(d))

// map -> json
m := map[string]string{
    "a":"aa",
    "b":"bb",
    "c":"cc",
}
e,_ := json.marshalindent(m,"","\t")
fmt.println(string(e))

返回结果：

[
    "a",
    "b",
    "c"
]
{
    "a": "aa",
    "b": "bb",
    "c": "cc"
}

使用struct tag辅助构建json

struct能被转换的字段都是首字母大写的字段，但如果想要在json中使用小写字母开头的key，可以使用struct的tag来辅助反射。

例如，post结构增加一个首字母小写的字段createat。

type post struct {
    id      int      `json:"id"`
    content string   `json:"content"`
    author  string   `json:"author"`
    label   []string `json:"label"`
}


postp := &post{
    2,
    "hello world",
    "userb",
    []string{"linux", "shell"},
    }

p, _ := json.marshalindent(postp, "", "\t")
fmt.println(string(p))

结果：

{
    "id": 2,
    "content": "hello world",
    "author": "userb",
    "label": [
        "linux",
        "shell"
    ]
}

使用struct tag的时候，几个注意点：

1. tag中标识的名称将称为json数据中key的值
   
2. tag可以设置为`json:"-"`来表示本字段不转换为json数据，即使这个字段名首字母大写
   • 如果想要json key的名称为字符"-"，则可以特殊处理`json:"-,"`，也就是加上一个逗号
     
3. 如果tag中带有,omitempty选项，那么如果这个字段的值为0值，即false、0、""、nil等，这个字段将不会转换到json中
   
4. 如果字段的类型为bool、string、int类、float类，而tag中又带有,string选项，那么这个字段的值将转换成json字符串

例如：

type post struct {
    id      int      `json:"id,string"`
    content string   `json:"content"`
    author  string   `json:"author"`
    label   []string `json:"label,omitempty"`
}

解析json数据到struct(结构已知)

json数据可以解析到struct或空接口interface{}中(也可以是slice、map等)。理解了上面构建json时的tag规则，理解解析json就很简单了。

例如，下面是一段json数据：

{
    "id": 1,
    "content": "hello world",
    "author": {
        "id": 2,
        "name": "usera"
    },
    "published": true,
    "label": [],
    "nextpost": null,
    "comments": [{
            "id": 3,
            "content": "good post1",
            "author": "userb"
        },
        {
            "id": 4,
            "content": "good post2",
            "author": "userc"
        }
    ]
}

分析下这段json数据：

1. 顶层的大括号表示是一个匿名对象，映射到go中是一个struct，假设这个struct名称为post
   
2. 顶层大括号里的都是post结构中的字段，这些字段因为都是json数据，所以必须都首字母大写，同时设置tag，tag中的名称小写
   
3. 其中author是一个子对象，映射到go中是另一个struct，在post中这个字段的名称为author，假设名称和struct名称相同，也为author
   
4. label是一个数组，映射到go中可以是slice，也可以是array，且因为json array为空，所以go中的slice/array类型不定，比如可以是int，可以是string，也可以是interface{}，对于这里的示例来说，我们知道标签肯定是string
   
5. nextpost是一个子对象，映射到go中是一个struct，但因为json中这个对象为null，表示这个对象不存在，所以无法判断映射到go中struct的类型。但对此处的示例来说，是没有下一篇文章，所以它的类型应该也是post类型
   
6. comment是子对象，且是数组包围的，映射到go中，是一个slice/array，slice/array的类型是一个struct

分析之后，对应地去构建struct和struct的tag就很容易了。如下，是根据上面分析构建出来的数据结构：

type post struct {
    id        int64         `json:"id"`       
    content   string        `json:"content"`  
    author    author        `json:"author"`   
    published bool          `json:"published"`
    label     []string      `json:"label"`    
    nextpost  *post         `json:"nextpost"` 
    comments  []*comment    `json:"comments"` 
}

type author struct {
    id   int64  `json:"id"`  
    name string `json:"name"`
}

type comment struct {
    id      int64  `json:"id"`     
    content string `json:"content"`
    author  string `json:"author"` 
}

注意，前面在介绍构建json数据的时候说明过，指针会进行追踪，所以这里反推出来的struct中使用指针类型是没问题的。

于是，解析上面的json数据到post类型的对象中，假设这个json数据存放在a.json文件中。代码如下：

func main() {
    // 打开json文件
    fh, err := os.open("a.json")
    if err != nil {
        fmt.println(err)
        return
    }
    defer fh.close()
    // 读取json文件，保存到jsondata中
    jsondata, err := ioutil.readall(fh)
    if err != nil {
        fmt.println(err)
        return
    }
    
    var post post
    // 解析json数据到post中
    err = json.unmarshal(jsondata, &post)
    if err != nil {
        fmt.println(err)
        return
    }
    fmt.println(post)
}

输出结果：

{1 hello world {2 usera} true [] <nil> [0xc042072300 0xc0420723c0]}

也许你已经感受到了，从json数据反推算struct到底有多复杂，虽然逻辑不难，但如果数据复杂一点，这是件非常恶心的事情。所以，使用别人写好的工具来自动转换吧。本文后面有推荐json到数据结构的自动转换工具。

解析json到interface(结构未知)

上面是已知json数据结构的解析方式，如果json结构是未知的或者结构可能会发生改变的情况，则解析到struct是不合理的。这时可以解析到空接口interface{}或map[string]interface{}类型上，这两种类型的结果是完全一致的。

解析到interface{}上时，go类型和json类型的对应关系如下

  json类型             go类型                
---------------------------------------------
json objects    <-->  map[string]interface{} 
json arrays     <-->  []interface{}          
json booleans   <-->  bool                   
json numbers    <-->  float64                
json strings    <-->  string                 
json null       <-->  nil                    

例如：

func main() {
    // 读取json文件
    fh, err := os.open("a.json")
    if err != nil {
        fmt.println(err)
        return
    }
    defer fh.close()
    jsondata, err := ioutil.readall(fh)
    if err != nil {
        fmt.println(err)
        return
    }
    
    // 定义空接口接收解析后的json数据
    var unknown interface{}
    // 或：map[string]interface{} 结果是完全一样的
    err = json.unmarshal(jsondata, &unknown)
    if err != nil {
        fmt.println(err)
        return
    }
    fmt.println(unknown)
}

输出结果：

map[nextpost:<nil> comments:[map[id:3 content:good post1
author:userb] map[id:4 content:good post2 author:userc]]
id:1 content:hello world author:map[id:2 name:usera] published:true label:[]]

上面将输出map结构。这是显然的，因为类型对应关系中已经说明了，json object解析到go interface的时候，对应的是map结构。如果将上面输出的结构进行一下格式化，得到的将是类似下面的结构：

map[
    nextpost:<nil>
    comments:[
        map[
            id:3
            content:good post1
            author:userb
        ]
        map[
            id:4
            content:good post2
            author:userc
        ]
    ]
    id:1
    content:hello world
    author:map[
        id:2
        name:usera
    ]
    published:true
    label:[]
]

现在，可以从这个map中去判断类型、取得对应的值。但是如何判断类型？可以使用类型断言：

func main() {
    // 读取json数据
    fh, err := os.open("a.json")
    if err != nil {
        fmt.println(err)
        return
    }
    defer fh.close()
    jsondata, err := ioutil.readall(fh)
    if err != nil {
        fmt.println(err)
        return
    }
    
    // 解析json数据到interface{}
    var unknown interface{}
    err = json.unmarshal(jsondata, &unknown)
    if err != nil {
        fmt.println(err)
        return
    }

    // 进行断言，并switch匹配
    m := unknown.(map[string]interface{})
    for k, v := range m {
        switch vv := v.(type) {
        case string:
            fmt.println(k, "type: string\nvalue: ", vv)
            fmt.println("------------------")
        case float64:
            fmt.println(k, "type: float64\nvalue: ", vv)
            fmt.println("------------------")
        case bool:
            fmt.println(k, "type: bool\nvalue: ", vv)
            fmt.println("------------------")
        case map[string]interface{}:
            fmt.println(k, "type: map[string]interface{}\nvalue: ", vv)
            for i, j := range vv {
                fmt.println(i,": ",j)
            }
            fmt.println("------------------")
        case []interface{}:
            fmt.println(k, "type: []interface{}\nvalue: ", vv)
            for key, value := range vv {
                fmt.println(key, ": ", value)
            }
            fmt.println("------------------")
        default:
            fmt.println(k, "type: nil\nvalue: ", vv)
            fmt.println("------------------")
        }
    }
}

结果如下：

comments type: []interface{}
value:  [map[id:3 content:good post1 author:userb] map[author:userc id:4 content:good post2]]
0 :  map[id:3 content:good post1 author:userb]
1 :  map[id:4 content:good post2 author:userc]
------------------
id type: float64
value:  1
------------------
content type: string
value:  hello world
------------------
author type: map[string]interface{}
value:  map[id:2 name:usera]
name :  usera
id :  2
------------------
published type: bool
value:  true
------------------
label type: []interface{}
value:  []
------------------
nextpost type: nil
value:  <nil>
------------------

可见，从interface中解析非常复杂，而且可能因为嵌套结构而导致无法正确迭代遍历。这时候，可以使用第三方包simplejson，见后文。

解析、创建json流

除了可以直接解析、创建json数据，还可以处理流式数据。

• type decoder解码json到go数据结构
  
• type encoder编码go数据结构到json

例如：

const jsonstream = `
    {"name": "ed", "text": "knock knock."}
    {"name": "sam", "text": "who's there?"}
    {"name": "ed", "text": "go fmt."}
    {"name": "sam", "text": "go fmt who?"}
    {"name": "ed", "text": "go fmt yourself!"}
`
type message struct {
    name, text string
}
dec := json.newdecoder(strings.newreader(jsonstream))
for {
    var m message
    if err := dec.decode(&m); err == io.eof {
        break
    } else if err != nil {
        log.fatal(err)
    }
    fmt.printf("%s: %s\n", m.name, m.text)
}

输出：

ed: knock knock.
sam: who's there?
ed: go fmt.
sam: go fmt who?
ed: go fmt yourself!

再例如，从标准输入读json数据，解码后删除名为name的元素，最后重新编码后输出到标准输出。

func main() {
    dec := json.newdecoder(os.stdin)
    enc := json.newencoder(os.stdout)
    for {
        var v map[string]interface{}
        if err := dec.decode(&v); err != nil {
            log.println(err)
            return
        }
        for k := range v {
            if k != "name" {
                delete(v, k)
            }
        }
        if err := enc.encode(&v); err != nil {
            log.println(err)
        }
    }
}

json转go数据结构工具推荐

quicktype工具，可以轻松地将json文件转换成各种语言对应的数据结构。

地址：

在vscode中有相关插件

1. 先在命令面板中输入"set quicktype target language"选择要将json转换成什么语言的数据结构(比如go)
   
2. 再输入"open quicktype for json"就可以将当前json文件转换对应的数据结构(比如struct)

转换后只需按实际的需求稍微修改一部分类型即可。比如为json*匿名对象对应的struct设定名称，还有一些无法转换成struct时因为判断数据类型而使用的interface{}类型也要改一改。

例如，下面是使用quicktype工具对前面示例json数据进行转换后的数据结构：

type a struct {
    id        int64         `json:"id"`       
    content   string        `json:"content"`  
    author    author        `json:"author"`   
    published bool          `json:"published"`
    label     []interface{} `json:"label"`    
    nextpost  interface{}   `json:"nextpost"` 
    comments  []comment     `json:"comments"` 
}

type author struct {
    id   int64  `json:"id"`  
    name string `json:"name"`
}

type comment struct {
    id      int64  `json:"id"`     
    content string `json:"content"`
    author  string `json:"author"` 
}

其中需要将type a struct的a改成你自己的名称，将a中的interface{}也改成合理的类型。