（转）golang json解析

原文：https://blog.csdn.net/Guzarish/article/details/121847969

前言
Go 语言自带的 encode/json 包提供了对 JSON 数据格式的编码和解码能力。

解析 JSON 的关键，其实在于如何声明存放解析后数据的变量的类型。

此外使用 json 编码还会有几个需要注意的地方，谨防踩坑。

解析简单JSON
先观察下这段 JSON 数据的组成，name，created 是字符串。id 是整型，fruit 是一个字符串数组

{
"name": "Standard",
"fruit": [
"Apple",
"Banana",
"Orange"
],
"id": 999,
"created": "2018-04-09T23:00:00Z"
}
那么对应的在 Go 里面解析数据的类型应该被声明为：

type FruitBasket struct {
Name string `json:"name"`
Fruit []string `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
完整的解析 JSON 的代码如下：

package main

import (
"fmt"
"encoding/json"
"time"

)

func main() {
type FruitBasket struct {
Name string `json:"name"`
Fruit []string `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}

jsonData := []byte(`
{
"name": "Standard",
"fruit": [
"Apple",
"Banana",
"Orange"
],
"id": 999,
"created": "2018-04-09T23:00:00Z"
}`)

var basket FruitBasket
err := json.Unmarshal(jsonData, &basket)
if err != nil {
fmt.Println(err)
}
fmt.Println(basket.Name, basket.Fruit, basket.Id)
fmt.Println(basket.Created)
}
输出

Standard [Apple Banana Orange] 999
2018-04-09 23:00:00 +0000 UTC
由于 json.UnMarshal() 方法接收的是字节切片，所以首先需要把JSON字符串转换成字节切片 c := []byte(s)

解析内嵌对象的JSON
把上面的 fruit 键对应的值如果改成字典 变成 "fruit" : {"name":"Apple", "priceTag":"$1"}：

jsonData := []byte(`
{
"name": "Standard",
"fruit" : {"name": "Apple", "priceTag": "$1"},
"def": 999,
"created": "2018-04-09T23:00:00Z"
}`)
那么 Go 语言里存放解析数据的类型应该这么声明

type Fruit struct {
Name string `json":name"`
PriceTag string `json:"priceTag"`
}

type FruitBasket struct {
Name string `json:"name"`
Fruit Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
解析内嵌对象数组的JSON
如果上面 JSON 数据里的 Fruit 值现在变成了

"fruit" : [
{
"name": "Apple",
"priceTag": "$1"
},
{
"name": "Pear",
"priceTag": "$1.5"
}
]
这种情况也简单把存放解析后数据的类型其声明做如下更改，把 Fruit 字段类型换为 []Fruit 即可

type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}

type FruitBasket struct {
Name string `json:"name"`
Fruit []Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
解析具有动态Key的
下面再做一下复杂的变化，如果把上面的对象数组变为以 Fruit 的 Id 作为属性名的复合对象(object of object)比如：

"Fruit" : {
"1": {
"Name": "Apple",
"PriceTag": "$1"
},
"2": {
"Name": "Pear",
"PriceTag": "$1.5"
}
}
每个 Key 的名字在声明类型的时候是不知道值的，这样该怎么声明呢，答案是把 Fruit 字段的类型声明为一个 Key 为 string 类型值为 Fruit 类型的 map

type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}

type FruitBasket struct {
Name string `json:"name"`
Fruit map[string]Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
运行下面完整的代码

package main

import (
"encoding/json"
"fmt"
"time"
)

func main() {
type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}

type FruitBasket struct {
Name string `json:"name"`
Fruit map[string]Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
jsonData := []byte(`
{
"Name": "Standard",
"Fruit" : {
"1": {
"name": "Apple",
"priceTag": "$1"
},
"2": {
"name": "Pear",
"priceTag": "$1.5"
}
},
"id": 999,
"created": "2018-04-09T23:00:00Z"
}`)

var basket FruitBasket
err := json.Unmarshal(jsonData, &basket)
if err != nil {
fmt.Println(err)
}
for _, item := range basket.Fruit {
fmt.Println(item.Name, item.PriceTag)
}
}
输出

Apple $1
Pear $1.5
解析包含任意层级的数组和对象的JSON数据
针对包含任意层级的 JSON 数据，encoding/json 包使用：

map[string]interface{} 存储 JSON 对象

[]interface 存储JSON数组

json.Unmarshl 将会把任何合法的JSON数据存储到一个 interface{} 类型的值，通过使用空接口类型我们可以存储任意值，但是使用这种类型作为值时需要先做一次类型断言。

jsonData := []byte(`{"Name":"Eve","Age":6,"Parents":["Alice","Bob"]}`)

var v interface{}
json.Unmarshal(jsonData, &v)
data := v.(map[string]interface{})

for k, v := range data {
switch v := v.(type) {
case string:
fmt.Println(k, v, "(string)")
case float64:
fmt.Println(k, v, "(float64)")
case []interface{}:
fmt.Println(k, "(array):")
for i, u := range v {
fmt.Println(" ", i, u)
}
default:
fmt.Println(k, v, "(unknown)")
}
}
虽然将 JSON 数据存储到空接口类型的值中可以用来解析任意结构的 JSON 数据，但是在实际应用中发现还是有不可控的地方，比如将数字字符串的值转换成了 float 类型的值，所以经常会在运行时报类型断言的错误，所以在 JSON 结构确定的情况下还是优先使用结构体类型声明，将 JSON 数据到结构体中的方式来解析 JSON。

用 Decoder解析数据流
上面都是使用的 UnMarshall 解析的 JSON 数据，如果 JSON 数据的载体是打开的文件或者 HTTP 请求体这种数据流(他们都是 io.Reader 的实现)，我们不必把 JSON 数据读取出来后再去调用 encode/json 包的 UnMarshall 方法，包提供的 Decode 方法可以完成读取数据流并解析 JSON 数据最后填充变量的操作。

package main

import (
"encoding/json"
"fmt"
"io"
"log"
"strings"
)

func main() {
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 编码需要注意的几个点
自定义JSON键名
只有选择用大写字母开头的字段名称，导出的结构体成员才会被编码。

在编码时，默认使用结构体字段的名字作为 JSON 对象中的 key，我们可以在结构体声明时，在结构体字段标签里可以自定义对应的 JSON key，如下：

type Fruit struct {
Name string `json:"nick_name"`
PriceTag string `json:"price_level_tag"`
}
编码JSON时忽略掉指定字段
并不是所有数据我们都期望编码到 JSON 中暴露给外部接口的，所以针对一些敏感的字段我们往往希望将其从编码后的 JSON 数据中忽略掉。

为了维持结构体字段的导出性又能让其在 JSON 数据中被忽略，我们可以使用结构体的标签进行注解，比如下面定义的结构体，可以把身份证 IdCard 字段在 JSON 数据中去掉：

type User struct {
Name string `json:"name"`
Age int `json:"int"`
IdCard string `json:"-"`
}
encoding/json 的源码中和文档中都列举了通过结构体字段标签控制数据 JSON 编码行为的说明：

// 忽略字段

Field int `json:"-"`

// 自定义key

Field int `json:"myName"`

// 数据为空时忽略字段

Field int `json:"myName,omitempty"`
omitempty 当字段的数据为空时，在 JSON 中省略这个字段，为的是节省数据空间。但是在 Api开发中不常用，因为字段不固定对前端很不友好。

解决空切片在JSON里被编码成null
结构体字段标签的 json 注解中都不加 omitempty 后还遇到一种情况，数据类型为切片的字段在数据为空的时候会被 JSON编码为 null 而不是 []。

因为切片的零值为 nil，无指向内存的地址，所以当以这种形式定义 varf[]int 初始化 slice 后，在 JSON 中将其编码为 null，如果想在 JSON 中将空 slice 编码为 [] 则需用make初始化 slice 为其分配内存地址：

运行下面的例子可以看出两点的区别：

package main

import (
"encoding/json"
"fmt"
)

type Person struct {
Friends []string
}

func main() {
var f1 []string
f2 := make([]string, 0)

json1, _ := json.Marshal(Person{f1})
json2, _ := json.Marshal(Person{f2})

fmt.Printf("%s\n", json1)
fmt.Printf("%s\n", json2)
}
输出

{"Friends":null}
{"Friends":[]}
导致这个问题的原因是 Go 的 append 函数，在给切片追加元素时，会判断切片是否已初始化，没有的话会帮其初始化分配底层数组，可如果没有数据进行添加时，会导致切片依旧是声明的 nil值。
————————————————