JSON 序列化和反序列化

    在 Go 中我们主要使用官方的 encoding/json 包对 JSON 数据进行序列化和反序列化，主要使用方法有：

    • 序列化:

    • 反序列化：

      1. func Unmarshal(data []byte, v interface{}) error

    简单例子：

    1. package main
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6. )
    8. func main() {
    9.     var (
    10.         data  = `1`
    11.         value int
    12.     )
    14.     err1 := json.Unmarshal([]byte(data), &value)
    16.     fmt.Println("Unmarshal error is:", err1)
    17.     fmt.Printf("Unmarshal value is: %T, %d \n", value, value)
    19.     value2, err2 := json.Marshal(value)
    21.     fmt.Println("Marshal error is:", err2)
    22.     fmt.Printf("Marshal value is: %s \n", string(value2))
    23. }
    1. Unmarshal error is: <nil>
    2. Unmarshal value is: int, 1 
    3. Marshal error is: <nil>
    4. Marshal value is: 1

    在这个例子中，我们使用 Unmarshal 和 Marshal 将一个整数的 JSON 二进制转化为 go int 数据。

    例如：我们把上面例子中 value 类型由 int 修改为 string 后再次运行代码，你将得到 Unmarshal error is: json: cannot unmarshal number into Go value of type string 的错误提醒。

    JSON 和 Go 数据类型对照表：

    1. package main
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6. )
    8. func main() {
    9.     var (
    10.         d1 = `false`
    11.         v1 bool
    12.     )
    14.     json.Unmarshal([]byte(d1), &v1)
    15.     printHelper("d1", v1)
    17.     var (
    18.         d2 = `2`
    19.         v2 int
    20.     )
    22.     json.Unmarshal([]byte(d2), &v2)
    23.     printHelper("d2", v2)
    26.         d3 = `3.14`
    27.     )
    29.     json.Unmarshal([]byte(d3), &v3)
    30.     printHelper("d3", v3)
    32.     var (
    33.         d4 = `[1,2]`
    34.         v4 []int
    35.     )
    37.     json.Unmarshal([]byte(d4), &v4)
    38.     printHelper("d4", v4)
    40.     var (
    41.         d5 = `{"a": "b"}`
    42.         v5 map[string]string
    43.         v6 interface{}
    44.     )
    46.     json.Unmarshal([]byte(d5), &v5)
    47.     printHelper("d5", v5)
    49.     json.Unmarshal([]byte(d5), &v6)
    50.     printHelper("d5(interface{})", v6)
    51. }
    53. func printHelper(name string, value interface{}) {
    54.     fmt.Printf("%s Unmarshal value is: %T, %v \n", name, value, value)
    55. }

    运行代码我们可以得到如下输出结果：

    除了使用上面基础数据外，对于那些比较复杂的数据集合（Object），我们还可以使用自定义数据类型 struct 来转化。

    • Go 中关于 JSON 转化字段名的对应语法为：
    1. Field int `json:"myName"`
    • 如果我们想忽略那些空值的字段，我们可以使用 omitempty 选项：
    1. Field int `json:"myName,omitempty"`
    • 如果我们想忽略特定字段:
    1. Field int `json:"-"`

    组合示例：

    1. type A struct {
    2.     A int     `json:"k"`
    3.     B string  `json:"b,omitempty"`
    4.     C float64 `json:"-"`
    5. }

    假如我们有这样一段 JSON 数据，它表示一个学生的考试成绩，下面我们就来看看在 Go 中如何序列化和反序列化。

    • 数据准备:
    • 反序列化：
    1. package main
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6.     "io/ioutil"
    7. )
    9. type Result struct {
    10.     Name  string  `json:"name"`
    11.     Score float64 `json:"score"`
    12. }
    14. type Student struct {
    15.     Id int `json:"id"`
    17.     Name    string   `json:"name"`
    18.     Results []Result `json:"results"`
    20. func main() {
    21.     dat, _ := ioutil.ReadFile("data.json")
    23.     var s Student
    24.     json.Unmarshal(dat, &s)
    25.     fmt.Printf("Student's result is: %v\n", s)
    26. }
    1. Student's result is: {1 小红 [{语文 90} {数学 100}]}
    • 序列化：
    1. package main
    3. import (
    4.     "encoding/json"
    5.     "io/ioutil"
    6. )
    8. type Result struct {
    9.     Name  string  `json:"name"`
    10.     Score float64 `json:"score"`
    11. }
    13. type Student struct {
    14.     Id int `json:"id"`
    16.     Name    string   `json:"name"`
    17.     Results []Result `json:"results"`
    18. }
    20. func main() {
    21.     s := Student{
    22.         Id:   1,
    23.         Name: "小红",
    24.         Results: []Result{
    25.             Result{
    26.                 Name:  "语文",
    27.                 Score: 90,
    28.             },
    29.             Result{
    30.                 Name:  "数学",
    31.                 Score: 100,
    32.             },
    33.         },
    34.     }
    36.     dat, _ := json.Marshal(s)
    37.     ioutil.WriteFile("data2.json", dat, 0755)
    38. }

    当我们运行代码后，打开 data2.json 文件，将看到如下内容: 

    1. {
    2.     "id": 1,
    3.     "name": "小红",
    4.     "results": [
    5.         {
    6.             "name": "语文",
    7.             "score": 90
    8.         },
    9.         {
    10.             "name": "数学",
    11.             "score": 100
    12.         }
    13. }