Golang中的JSON序列化和反序列化

JSON

在JS语言中，一切都是对象。因此，任何的数据类型都可以通过JSON来表示，例如字符串、数字、对象、数组. map.结构体等.

JSON键值对是用来保存数据一种方式，

键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值

JSON序列化

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

package main

import (
	"encoding/json"
	"fmt"
)

//定义结构体
type Monster struct {
	Name     string  `json:"name"`
	Age      int     `json:"age"`
	Birthday string  `json:"birthday"`
	Sal      float64 `json:"sal"`
	Skill    string  `json:"skill"`
}

func testStruct() {
	monster := Monster{
		Name:     "牛魔王",
		Age:      500,
		Birthday: "2022-01-06",
		Sal:      8000.0,
		Skill:    "牛魔拳",
	}

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

//将map进行序列化
func testMap() {
	//定义一个map
	var a map[string]interface{}
	a = make(map[string]interface{})
	a["name"] = "红孩儿"
	a["age"] = 30
	a["address"] = "洞"

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

//切片序列化
func testSlice() {
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "jack"
	m1["age"] = 7
	m1["address"] = "北京"
	slice = append(slice, m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "tom"
	m2["age"] = 6
	m2["address"] = "北京"
	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 testFloat64() {
	var num1 float64 = 2324.4

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

}

func main() {
	//结构体，map，切片进行序列化
	testStruct()
	testMap()
	testSlice()
	testFloat64()
}

JSON反序列化

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

package main

import (
   "encoding/json"
   "fmt"
)

type Monster struct {
   Name     string  `json:"name"`
   Age      int     `json:"age"`
   Birthday string  `json:"birthday"`
   Sal      float64 `json:"sal"`
   Skill    string  `json:"skill"`
}

//演示将json字符串，反序列化为struct
func unmarshalStruct() {
   str := "{\"name\":\"牛魔王\",\"age\":500,\"birthday\":\"2022-01-06\",\"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 name = %v \n", monster, monster.Name)
}

//将json字符串，反序列化成map
func unmarshalMap() {
   str := "{\"address\":\"洞\",\"age\":30,\"name\":\"红孩儿\"}\n"

   //定义一个map
   var a map[string]interface{}

   //反序列化不用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 unmarshalSlice() {
   str := "[{\"address\":\"北京\",\"age\":7,\"name\":\"jack\"},{\"address\":\"北京\",\"age\":6,\"name\":\"tom\"}]"
   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)
}
func main() {

   unmarshalStruct()
   unmarshalMap()
   unmarshalSlice()
}

1. 在反序列化一个json字符串时，要确保反序列化后的数据类型要和原来序列化前的数据类型一致。
2. 如果json字符串是通过程序获取到的，则不需要再对“转义处理。

个人博客地址