22.Go语言·Json使用·序列化·反序列化

main.go

// Go语言·Json使用·序列化·反序列化
package main

//  包的本质是创建不同的文件夹
//  go的每一个文件都是属于一个包的
//  go以包的形式管理项目和文件目录。
//  import "包的路径"
import (
    model "day28/model"
)

var content string = `
————————————————Go语言·Json使用·序列化·反序列化————————————————————
在线解析工具：
    https://www.json.cn
一、Json基本介绍
    JavaScript Object Notation
    轻量级的数据交互格式。 
    key-value
    [
        {"name":"Uzi","age":18,"zone":"LPL","ability":["ADC","SUP","Mid"]},
        {"name":"Faker","age":18,"zone":"LCK","ability":["APC","Top"]}
    ]
    任何数据类型都可以转成Json格式：
二、json序列化操作：
    数组
    map
    切片
    结构体
    基本数据类型，可以序列化，但没必要。
    **温馨提示：结构体序列化：
        设置tag标签，设置序列化的key值。

三、反序列化
    1.在反序列化一个json字符串时，要确保反序列化后的数据类型必须跟
    原来序列化之前的数据保持一致。
    2.如果json字符串是通过程序获得的，则不需要对双引号""转义处理

`


func main() {
    model.Entry()
}

model/Utils.go

package model

import (
    "fmt"
    "encoding/json"
)


type Monster struct {
    Name string `json:"name"`
    Age int     `json:"age"`
    Skill string `json:"skill"`
}

/**
 * [Init 入口]
 * @author Jhou Shuai
 * @datetime 2019-05-18T11:58:33+0800
 */
func Entry() {
    testSliceUnMarshal()
}

// 结构体
func testStruct() {
    monter := Monster{
        Name:"小可爱",
        Age:18,
        Skill:"嘤嘤嘤",
    }
    data,err := json.Marshal(&monter)
    if err!=nil{
        fmt.Printf("序列化失败：%v \n", err)
    }
    fmt.Println(string(data))
}

// map
func testMap() {
    var a map[string]interface{}
    a = make(map[string]interface{})
    a["name"] = "小甜点"
    a["age"] = 18
    a["address"] = "玉林"

    data,err := json.Marshal(a)
    if err!=nil{
        fmt.Printf("序列化失败：%v \n", err)
    }
    fmt.Println(string(data))
}

// 切片
func testSlice() {
    var slice []map[string]interface{}

    var a map[string]interface{} = make(map[string]interface{})
    a["name"] = "小甜点"
    a["age"] = 18
    a["address"] = [...]string{"玉林","春熙路"}
    slice = append(slice,a)

    var b map[string]interface{} = make(map[string]interface{})
    b["name"] = "小丁丁"
    b["age"] = 19
    b["address"] = [...]string{"一品天下","武侯祠"}
    slice = append(slice,b)

    data,err := json.Marshal(slice)
    if err!=nil{
        fmt.Printf("序列化失败：%v \n", err)
    }
    fmt.Println(string(data))
}


// 数组
func testArray() {
    var intArr  = [...]int{1,2,3,4,5}
    data,err := json.Marshal(intArr)
    if err!=nil{
        fmt.Printf("序列化失败：%v \n", err)
    }
    fmt.Println(string(data))
}

// 基本数据类型
func testFloat64() {
    var num1 float64 = 100.11
    data,err := json.Marshal(num1)
    if err!=nil{
        fmt.Printf("序列化失败：%v \n", err)
    }
    fmt.Println(string(data))
}


// 结构体反序列化
func testStructUnMarshal() {
    str := "{\"name\":\"小可爱\",\"age\":18,\"skill\":\"嘤嘤嘤\"}"
    var monster Monster
    err := json.Unmarshal([]byte(str),&monster)
    if err!=nil{
        fmt.Printf("反序列化失败：%v \n", err)
    }
    fmt.Println(monster)
}

// 反序列化map，不需要make
// 因为make操作被封装到Unmarshal函数中咯
func testMapUnMarshal() {
    str :="{\"address\":\"玉林\",\"age\":18,\"name\":\"小甜点\"}"
    var a map[string]interface{}
    err := json.Unmarshal([]byte(str),&a)
    if err!=nil{
        fmt.Printf("反序列化失败：%v \n", err)
    }
    fmt.Println(a)
    // map[address:玉林 age:18 name:小甜点]
}

// 反序列化slice
func testSliceUnMarshal() {
    str := "["+
        "{\"address\":[\"玉林\",\"春熙路\"],\"age\":18,\"name\":\"小甜点\"},"+
        "{\"address\":[\"一品天下\",\"武侯祠\"],\"age\":19,\"name\":\"小丁丁\"}"+
    "]"
    var slice []map[string]interface{} //反序列化map，不需要make
    err := json.Unmarshal([]byte(str),&slice)
    if err!=nil{
        fmt.Printf("反序列化失败：%v \n", err)
    }
    fmt.Println(slice)
    // [
    //  map[address:[玉林 春熙路] age:18 name:小甜点]
    //  map[address:[一品天下 武侯祠] age:19 name:小丁丁]
    // ]

}