使用Go语言解析动态JSON格式的方法

通常使用golang encoding/json 标准库可以方便的编码/解析json数据，但是前提需要定义struct数据结构。特别是解析未知结构的json数据时，原有方法很难满足需求了，本文主要介绍动态解析json格式。

go语言的json 库

go语言自带的json转换库为 encoding/json

1.1）其中把对象转换为json的方法（函数）为 json.marshal()，其函数原型如下

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

也就是说，这个函数接收任意类型的数据 v，并转换为字节数组类型，返回值就是我们想要的json数据和一个错误代码。当转换成功的时候，这个错误代码为nil

在进行对象转换为 json 的过程中，会遵循如下几条规则：

1. 布尔型转换为 json 后仍是布尔型　， 如true -> true
2. 浮点型和整数型转换后为json里面的常规数字，如 1.23 -> 1.23
3. 字符串将以utf-8编码转化输出为unicode字符集的字符串，特殊字符比如<将会被转义为\u003c
4. 数组和切片被转换为json 里面的数组，[]byte类会被转换为base64编码后的字符串，slice的零值被转换为null
5. 结构体会转化为json对象，并且只有结构体里边以大写字母开头的可被导出的字段才会被转化输出，而这些可导出的字段会作为json对象的字符串索引
6. 转化一个map 类型的数据结构时，该数据的类型必须是 map[string]t（t 可以是encoding/json 包支持的任意数据类型）

1.2）把 json 转换回对象的方法（函数）为 json.unmarshal()，其函数原型如下

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

这个函数会把传入的 data 作为一个json来进行解析，解析后的数据存储在参数 v 中。这个参数 v 也是任意类型的参数（但一定是一个类型的指针），原因是我们在是以此函数进行json 解析的时候，这个函数不知道这个传入参数的具体类型，所以它需要接收所有的类型。

那么，在进行解析的时候，如果json 和 对象的结构不对口会发生什么呢，这就需要解析函数json.unmarshal()遵循以下规则

json.unmarshal() 函数会根据一个约定的顺序查找目标结构中的字段，如果找到一个即发生匹配。那什么是找到了呢？关于“找到了”又有如下的规则：假设一个json对象有个名为"foo"的索引，要将"foo"所对应的值填充到目标结构体的目标字段上，json.unmarshal() 将会遵循如下顺序进行查找匹配

1. § 一个包含foo 标签的字段
2. §  一个名为foo 的字段
3. § 一个名为foo 或者foo 或者除了首字母其他字母不区分大小写的名为foo 的字段。 这些字段在类型声明中必须都是以大写字母开头、可被导出的字段。

注意：如果json中的字段在go目标类型中不存在，json.unmarshal() 函数在解码过程中会丢弃该字段。

当json 的结构是未知的时候，会遵循如下规则：

1. § json中的布尔值将会转换为go中的bool类型
2. § 数值会被转换为go中的float64类型
3. § 字符串转换后还是string类型
4. § json数组会转换为[]interface{} 类型
5. § json对象会转换为map[string]interface{}类型
6. § null值会转换为nil

注意：在go的标准库encoding/json包中，允许使用map[string]interface{}和[]interface{} 类型的值来分别存放未知结构的json对象或数组

1、传统方法

比如 user 数据结构如下：

type user struct {
 name string `json:"name"`
 age int  `json:"age"`
}

在定义struct字段的时候，可以在字段后面添加tag，来控制encode/decode的过程：是否要 decode/encode 某个字段，json 中的字段名称是什么。字段名首字母控制字段的可见性，若要输出到json，首字母需要大写。

三种tag：

- ：不要解析这个字段

omitempty ：当字段为空（默认值）时，不要解析这个字段。比如 false、0、nil、长度为 0 的 array，map，slice，string

fieldname ：当解析 json 的时候，使用这个名字

举例来说吧：

// 解析的时候忽略该字段。默认情况下会解析这个字段，因为它是大写字母开头的
field int `json:"-"`
// 解析（encode/decode） 的时候，使用 `other_name`，而不是 `field`
field int `json:"other_name"`
// 解析的时候使用 `other_name`，如果struct 中这个值为空，就忽略它
field int `json:"other_name,omitempty"`

（1）encode

user := user{name: "test", age:23}
data, err := json.marshal(user)
if err != nil {
 fmt.println(string(data))
}

data 就是 []byte 类型的数组，里面包含了解析为 json 之后的数据，可以使用string(data)转型为string。

（2）decode

要把json数据转换成go类型的值（decode），可以使用 json.unmarshal 。

var user user
err = json.unmarshal(data, &user)
if err != nil {
 fmt.errorf("can not decode data: %v\n", err)
}

2、动态解析

动态json结构未知，若使用前面方法需要事先定义数据结构，这与php/python json处理非常不同。若不考虑性能，使用simplejson。

（1）simplejson

js, err := simplejson.newjson([]byte(`{
 "test": {
  "string_array": ["asdf", "zxcv"],
  "array": [1, "2", 3],
  "arraywithsubs": [{"subkeyone": 1},
  "bignum": 9223372036854775807,
  "string": "simplejson",
  "bool": true
 }
 }`))
 if err != nil {
  panic("json format error")
 }
 //获取某个字段值
 s, err := js.get("test").get("string").string()
 if err != nil {
  panic(err)
 }
 fmt.println(s)
 //检查某个字段是否存在
 _, ok := js.get("test").checkget("string2")
 if ok {
  fmt.println("存在！")
 } else {
  fmt.println("不存在")
 }

（2）interface

比如json有以下两种类型：

{"type":"sound","msg":{"description":"dynamite","authority":"the bruce dickinson"}}
{"type":"cowbell","msg":{"more":true}}

msg 具体什么类型实现无法判断， msg being a map[string]interface{} ：

type envelope struct {
 type string
 msg interface{}
}

var env envelope
if err := json.unmarshal([]byte(input), &env); err != nil {
  log.fatal(err)
 }
// for the love of gopher do not do this
var desc string = env.msg.(map[string]interface{})["description"].(string)
fmt.println(desc)

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。