JavaScript Object Notation(JSON)是一个数据交换标准，因其简单、可读性强广泛使用。Go语言中有一个"encoding/json"标准包，里面有完整的解析JSON字符串的功能支持
Go类型和JSON类型的对应关系如下：
- bool 代表 JSON booleans,
- 浮点数, 整数, Number -> JSON number，
- string 代表 JSON strings,
- nil 代表 JSON null.
- 数组、切片 -> JSON数组
- struct、map -> JSON object
（1）将JSON数据解析成结构体，需要用到 Unmarshal 函数，该函数的源码如下
func Unmarshal(data []byte, v interface{}) error {
//检查结构良好。
//避免填写半数据结构
//在发现JSON语法错误之前
var d decodeState
err := checkValid(data, &d.scan)
if err != nil {
return err
}
d.init(data)
return d.unmarshal(v)
}
解析示例
首先定义一个结构体与数组切片
//与json数据对应的结构体
type Server struct {
ServerName string
ServerIP string
}
// 数组对应slice
type ServerSlice struct {
Servers []Server
}
然后将JSON数据解析成结构体
package main
import (
"encoding/json"
"fmt"
)
func main() {
var s ServerSlice
str := `{"servers":[{"serverName":"TianJin","serverIP":"127.0.0.1"},
{"serverName":"Beijing","serverIP":"127.0.0.2"}]}`
json.Unmarshal([]byte(str), &s)
fmt.Println(s)
}
----output-----
{[{TianJin 127.0.0.1} {Beijing 127.0.0.2}]}
按照上述代码可以正常的将JSON解析成结构体，JSON在struct字段相中查找对应的字段有以下几个规则：
①首先会查找struct字段中所有的可导出的struct字段(所谓可导出就是首字母大写)，然后去自己的JSON数据中找对应字段的数据
②JSON数据中对应的字段无关大小写，只要值相同即可
因此上面的Server 结构体中的 ServerName 改为 serverName的话，输出结果就只有后面的 ServerIP 了
{[{ 127.0.0.1} { 127.0.0.2}]}
（2）将结构体解析为JSON数据，需要用到 Unmarshal 函数，该函数的源码如下
func Marshal(v interface{}) ([]byte, error) {
e := &encodeState{}
err := e.marshal(v, encOpts{escapeHTML: true})
if err != nil {
return nil, err
}
return e.Bytes(), nil
}
将结构体解析成JSON数据
func main() {
var s ServerSlice
s.Servers = append(s.Servers,Server{ServerName:"TianJin",
ServerIP:"127.0.0.1"})
s.Servers = append(s.Servers,Server{ServerName:"BeiJing",
ServerIP:"127.0.0.1"})
if data, err := json.Marshal(s); err == nil {
fmt.Printf("%s\n", data)
}
}
---output---
{"Servers":[{"ServerName":"TianJin","ServerIP":"127.0.0.1"},
{"ServerName":"BeiJing","ServerIP":"127.0.0.1"}]}
如果我们要自己定义生成的JSON数据的字段名呢？我们可以通过 struct tag定义来实现
//与json数据对应的结构体
type Server struct {
ServerName string `json:"serverName1"`
ServerIP string `json:"serverIP2"`
}
// 数组对应slice
type ServerSlice struct {
Servers []Server `json:"servers3"`
}
上面的JSON就会变为下面结果
{"servers3":[{"serverName1":"TianJin","serverIP2":"127.0.0.1"},
{"serverName1":"BeiJing","serverIP2":"127.0.0.1"}]}
针对JSON的输出，我们在定义struct tag的时候需要注意的几点是:
1 字段的tag是 "-" ，那么这个字段不会输出到JSON
2 tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中，例如上面例子中serverName
3 tag中如果带有 "omitempty" 选项，那么如果该字段值为空，就不会输出到JSON串中
4 如果字段类型是bool, string, int, int64等，而tag中带有 ",string" 选项，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串
举例说明
type Server struct {
// ID 不会导出到 JSON 中
ID int `json:"-"`
// ServerName 会在JSON中被 serverName 覆盖
ServerName string `json:"serverName"`
//转换成JSON字符串
ServerName2 string `json:"serverName2,string"`
// 如果 ServerIP 为空，则不输出到 JSON 串中
ServerIP string `json:"serverIP,omitempty"`
}
s := Server {
ID: 3,
ServerName: `Go "1.0" `,
ServerName2: `Go "1.0" `,
ServerIP: ``,
}
b, _ := json.Marshal(s)
os.Stdout.Write(b)
会输出以下内容：
{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}
Marshal函数只有在转换成功的时候才会返回数据，在转换的过程中我们需要注意几点：
①JSON对象只支持string作为key，所以要编码一个map，那么必须是map[string]T这种类型(T是Go语言中任意的类型)
②Channel, complex和function是不能被编码成JSON的
③嵌套的数据是不能编码的，不然会让JSON编码进入死循环
④指针在编码的时候会输出指针指向的内容，而空指针会输出null
上面解析方式是在我们知晓被解析的JSON数据的结构的前提下采取的方案，如果我们不知道被解析的数据的格式，又应该如何来解析呢？
（3）将JSON解析到interface
现在我们假设有如下的JSON数据
b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
在我们不知道他的结构的情况下，我们把他解析到interface{}里面
var f interface{}
err := json.Unmarshal(jsonData, &f)
这个时候f里面存储了一个map类似，他们的key是string，值存储在空的interface{}里
f = map[string]interface{}{
"Name": "Wednesday",
"Age": 6,
"Parents": []interface{}{
"Gomez",
"Morticia",
}，
}
那么如何来访问这些数据呢？通过断言的方式：
m := f.(map[string]interface{})
通过断言之后，你就可以通过如下方式来访问里面的数据了
for k, v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k, "is string", vv)
case int:
fmt.Println(k, "is int", vv)
case []interface{}:
fmt.Println(k, "is an array:")
for i, u := range vv {
fmt.Println(i, u)
}
default:
fmt.Println(k, "is of a type I don't know how to handle")
}
}
参考书籍：《Go Web编程》
