Go JSON 编码与解码？

JSON 简介

1. 什么是 JSON？

JSON 全称为 Javascript Object Notation，一种数据结构化交互的标准协议，易于浏览与编写，所以在数据交互时宽泛应用。

2. JSON 中的数据类型

• 数字：有十进制和迷信记数学两种示意形式。
• 字符串：应用双引号示意的 Unicode 字符序列。
• 布尔：true 或者 false。
• 对象：花括号 ({}) 括起来的一个或多个键值对 (key/value)，用 逗号 (,) 隔开，最初一个键值对前面不能有逗号，键必是双引号 ("") 引起来的字符串，而值则可是作意类型(布尔、数字、对象、数组、字符串)。
• 数组：中括号 ([]) 括号值的汇合，这些值可是任意类型(布尔、数字、对象、数组、字符串)。

上面的示例，是一个数组中包含两个对象。

[{"id":1,"username":"xiaoming","gender":1,"email":"xiaoming@163.com"},{"id":2,"username":"xiaohong","gender":2,"email":"xiaohong@163.com"}]

JSON 与 GO 联合

应用 encoding/json 解决 JSON 编码与解码时，就必须解决好 JSON 数据类型与 Go 语言数据类型的对应关系。

• JSON 的数字、字符串、布尔等在 Go 语言中相应内置数据类型一一对应。
• JSON 的数组则对应 Go 的数组或 Slice(切片)。
• JSON 的对象则对应 Go 的 struct(构造体)或 map。

编码一个构造体时，构造体中只有首字母大写的成员才会被编码，首字母小写的成员会被疏忽，另外，构造体中字段前面容许应用反引号申明成员的 Tag，用于阐明成员的元信息。

type Member struct {
    Id       int    `json:"id"`
    Username string `json:"username"`
    Sex      uint   `json:"gender"`
    Email    string `json:"email"`
}

下面的构造体 Member 中，咱们定义了四个成员，并申明了每个成员的 Tag 信息，其中 Sex 的 Tag 信息申明为 gender，所以编码后的后果为：

[{"id":1,"username":"xiaoming","gender":1,"email":"xiaoming@163.com"},{"id":2,"username":"xiaohong","gender":2,"email":"xiaohong@163.com"}]

编码

将 Go 语言的数据序列化为 JSON 字符串的操作，称为编码; 编码后的后果为一个 JSON 格局的字符串。

1. json.Marshal 函数

应用 json.Marshal 函数能够间接编码任意数据类型。

import (
    "encoding/json"
    "fmt"
)
func main() {members := []Member{
    {
        Id:1,
        Username:"小明",
        Sex:1,
        Email:"xiaoming@163.com",
    },
    {
        Id:2,
        Username:"小红",
        Sex:1,
        Email:"xiaohong@163.com",
    },
    {
        Id:3,
        Username:"小华",
        Sex:2,
        Email:"xiaohua@163.com",
    },
}
    data,_ := json.Marshal(members)
    fmt.Printf("%s",data)
}

运行后果：

[{"id":1,"username":"小明","gender":1,"email":"xiaoming@163.com"},{"id":2,"username":"小红","gender":1,"email":"xiaohong@163.com"},{"id":3,"username":"小华","gender":2,"email":"xiaohua@163.com"}]

json.Encoder

json.Marshal 实际上只是对 json.Encoder 的封装, 因而应用 json.Encoder 同样能够编码 JSON。

案例 1

func main(){b := &bytes.Buffer{}
    encoder := json.NewEncoder(b)
    err := encoder.Encode(members)
    if err != nil{panic(err)
    }

    fmt.Println(b.String())
}

案例 2

import (
    "encoding/json"
    "os"
)

type person struct {
    First       string
    Last        string
    Age         int
    notExported int
}

func main() {p1 := person{"James", "Bond", 20, 007}
    json.NewEncoder(os.Stdout).Encode(p1)
}

解码

将 JSON 字符串反序列化为 Go 绝对应类型的作品，称为解码。

1. json.Unmarshal 函数

json.Unmarshal 与 json.Marshal 函数相同，用于解码 JSON 字符串。

案例 3

func main() {
    str := `[
    {
        "id": 1,
        "username": "小明",
        "gender": 1,
        "email": "xiaoming@163.com"
    },
    {
        "id": 2,
        "username": "小红",
        "gender": 1,
        "email": "xiaohong@163.com"
    },
    {
        "id": 3,
        "username": "小华",
        "gender": 2,
        "email": "xiaohua@163.com"
    }
    ]`

    b := bytes.NewBufferString(str)
    var members []Member
    err := json.Unmarshal(b.Bytes(),&members)
    if err != nil{panic(err)
    }
    fmt.Println(members)
}

运行后果：

[{1 小明 1 xiaoming@163.com} 
{2 小红 1 xiaohong@163.com} 
{3 小华 2 xiaohua@163.com}]

2. json.Decoder

func main(){b := bytes.NewBufferString(str)
    var members []Member
    decoder := json.NewDecoder(b)
    err = decoder.Decode(&members)
    if err != nil{panic(err)
    }
    fmt.Println(members)
}

案例 4

package main

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

type person struct {
    First       string
    Last        string
    Age         int
    notExported int
}

func main() {
    var p1 person
    rdr := strings.NewReader(`{"First":"James", "Last":"Bond", "Age":20}`)
    json.NewDecoder(rdr).Decode(&p1)

    fmt.Println(p1.First)
    fmt.Println(p1.Last)
    fmt.Println(p1.Age)
}

构造体转 json

import (
    "encoding/json"
    "fmt"
)

type person struct {
    First string `json:"first"`
    Last  string `json:"last"`
    Age   int `json:"wisdom score"`
}

func main() {p1 := person{"James", "Bond", 20}
    fmt.Println(p1)                  //{James Bond 20}

    bs, _ := json.Marshal(p1)
    fmt.Println(string(bs))         // {"first":"James","last":"Bond","wisdom score":20}

}

json 转构造体

import (
    "encoding/json"
    "fmt"
)
type person struct {
    First string
    Last  string
    Age   int
}
func main() {
    var p1 person
    bs := []byte(`{"First":"James", "Last":"Bond", "Age":20}`)
    json.Unmarshal(bs, &p1)

    fmt.Println("--------------")
    fmt.Println(p1.First)  // James
    fmt.Println(p1.Last)  //Bond
    fmt.Println(p1.Age)  //20
    fmt.Printf("%v \n", p1)   //{James Bond 20} 
    fmt.Printf("%T \n", p1) // main.person 
}