[GO语言基础] JSON序列化与反序列化（十四）

最新推荐文章于 2022-05-05 20:17:14 发布

小夕Coding

最新推荐文章于 2022-05-05 20:17:14 发布

阅读量145

点赞数

分类专栏： Go编程文章标签：字符串 python go golang json

本文链接：https://blog.csdn.net/weixin_54707168/article/details/114006099

版权

Go编程专栏收录该内容

96 篇文章 15 订阅

订阅专栏

本文详细介绍了Go语言中JSON的序列化和反序列化操作，包括结构体、map和切片的转换。通过示例代码展示了如何使用`json.Marshal`和`json.Unmarshal`进行数据转换，并提到了自定义结构体字段名称的方法。同时，文章强调了基本数据类型的序列化在实际应用中的意义和注意事项。

摘要由CSDN通过智能技术生成

JSON

JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。https://www.json.cn/

语法规则
在 JS 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON 来表示.
键/值对
JSON 键值对是用来保存 JS 对象的一种方式,键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值

    {"firstName": "Json"}

json 的序列化
json 序列化是指，将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成 json 字符串的操作。

结构体json序列化：

    type Monster struct {
        Name string
        Age int
        Birthday string
        Sal float64
        Skill string
    }

    func main() {
        monster := Monster{
            Name :"牛魔王",
            Age : 500 ,
            Birthday : "2011-11-11",
            Sal : 8000.0,
            Skill : "牛魔拳",
        }

        //将monster 序列化
        data, err := json.Marshal(&monster) //..
        if err != nil {
            fmt.Printf("序列号错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("monster序列化后=%v\n", string(data))
    }

map json序列化：

    func main() {
        //定义一个map
        var a map[string]interface{}
        //使用map,需要make
        a = make(map[string]interface{})
        a["name"] = "红孩儿"
        a["age"] = 30
        a["address"] = "洪崖洞"

        //将a这个map进行序列化
        //将monster 序列化
        data, err := json.Marshal(a)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("a map 序列化后=%v\n", string(data))
    }

切片json序列化：

    func main() {
        var slice []map[string]interface{}
        var m1 map[string]interface{}
        //使用map前，需要先make
        m1 = make(map[string]interface{})
        m1["name"] = "jack"
        m1["age"] = "7"
        m1["address"] = "北京"
        slice = append(slice, m1)

        var m2 map[string]interface{}
        //使用map前，需要先make
        m2 = make(map[string]interface{})
        m2["name"] = "tom"
        m2["age"] = "20"
        m2["address"] = [2]string{"墨西哥","夏威夷"}
        slice = append(slice, m2)

        //将切片进行序列化操作
        data, err := json.Marshal(slice)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("slice 序列化后=%v\n", string(data))
        
    }

基本数据类型序列化

对基本数据类型进行序列化意义不大

    func main() {
        var num1 float64 = 2345.67

        //对num1进行序列化
        data, err := json.Marshal(num1)
        if err != nil {
            fmt.Printf("序列化错误 err=%v\n", err)
        }
        //输出序列化后的结果
        fmt.Printf("num1 序列化后=%v\n", string(data))
    }

注意事项
对于结构体的序列化，如果我们希望序列化后的 key 的名字，又我们自己重新制定，那么可以给 struct指定一个 tag 标签.

type Monster struct {
	Name string `json:"monster_name"` //反射机制
	Age int `json:"monster_age"`
	Birthday string `json:"monster_birthday"`
	Sal float64 `json:"monster_sal"`
	Skill string `json:"monster_skill"`
}

func testStruct() {
	//演示
	monster := Monster{
		Name :"牛魔王",
		Age : 500 ,
		Birthday : "2011-11-11",
		Sal : 8000.0,
		Skill : "牛魔拳",
	}

	//将monster 序列化
	data, err := json.Marshal(&monster) //..
	if err != nil {
		fmt.Printf("序列号错误 err=%v\n", err)
	}
	//输出序列化后的结果
	fmt.Printf("monster序列化后=%v\n", string(data))

}

json 反序列化
json 反序列化是指，将 json 字符串反序列化成对应的数据类型(比如结构体、map、切片)的操作

json反序列化结构体：

    type Monster struct {
        Name string  
        Age int 
        Birthday string //....
        Sal float64
        Skill string
    }

    //演示将json字符串，反序列化成struct
    func main() {
        //说明str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
        str := "{\"Name\":\"牛魔王~~~\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"

        //定义一个Monster实例
        var monster Monster

        err := json.Unmarshal([]byte(str), &monster)
        if err != nil {
            fmt.Printf("unmarshal err=%v\n", err)
        }
        fmt.Printf("反序列化后 monster=%v monster.Name=%v \n", monster, monster.Name)
    }

json反序列化map：

func main() {
	str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
	//定义一个map
	var a map[string]interface{} 

	//反序列化
	//注意：反序列化map,不需要make,因为make操作被封装到 Unmarshal函数
	err := json.Unmarshal([]byte(str), &a)
	if err != nil {
		fmt.Printf("unmarshal err=%v\n", err)
	}
	fmt.Printf("反序列化后 a=%v\n", a)

}

json反序列化切片：

    func main() {
        str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," + 
            "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
        
        //定义一个slice
        var slice []map[string]interface{}
        //反序列化，不需要make,因为make操作被封装到 Unmarshal函数
        err := json.Unmarshal([]byte(str), &slice)
        if err != nil {
            fmt.Printf("unmarshal err=%v\n", err)
        }
        fmt.Printf("反序列化后 slice=%v\n", slice)
    }