Golang 结构体、Map、切片、普通类型的数据类型的序列化和反序列化

代码案例：

package main

import (
	"encoding/json"
	"fmt"
)

type People struct {
	Name    string `json:"name"` //序列化后的字段名字【自定义】
	Age     int    `json:"age"`
	Address string `json:"address"`
}

func main() {
	//序列化
	TestMarshalStruct()
	TestMarshalMap()
	TestMarshalSlice()
	TestMarshalFloat64()
	//反序列化
	TestUnMarshalStruct()
	TestUnMarshalMarshalMap()
	TestUnMarshalSlice()
}

// 结构体的序列化
func TestMarshalStruct() {
	people := People{
		Name:    "carver",
		Age:     29,
		Address: "beijing",
	}
	data, err := json.Marshal(people)
	if err != nil {
		fmt.Println("序列化错误 err=%v\n", err)
	}
	//序列化的结果
	fmt.Println(string(data))
}

// map的序列化【无序的】
func TestMarshalMap() {
	//定义一个map
	var a map[string]interface{}
	//使用map之前需要make
	a = make(map[string]interface{})
	a["name"] = "孙悟空"
	a["age"] = 123
	a["address"] = "花果山"
	data, err := json.Marshal(a)
	if err != nil {
		fmt.Println("序列化错误 err=%v\n", err)
	}
	//序列化的结果
	fmt.Println(string(data))
}

// 切片的序列化
func TestMarshalSlice() {
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	//使用map前需要make
	m1 = make(map[string]interface{})
	m1["name"] = "carver"
	m1["age"] = 43
	m1["address"] = [2]string{"beijing", "shanghai"}
	slice = append(slice, m1)

	var m2 map[string]interface{}
	//使用map前需要make
	m2 = make(map[string]interface{})
	m2["name"] = "carver1"
	m2["age"] = 55
	m2["address"] = "tianjin"
	slice = append(slice, m2)

	data, err := json.Marshal(slice)
	if err != nil {
		fmt.Println("序列化错误 err=%v\n", err)
	}
	//序列化的结果
	fmt.Println(string(data))
}

// 基本数据类型序列化
func TestMarshalFloat64() {
	var num float64 = 63.9
	data, err := json.Marshal(num)
	if err != nil {
		fmt.Println("序列化错误 err=%v\n", err)
	}
	//序列化的结果
	fmt.Println(string(data))
}

// json字符串反序列化为结构体
func TestUnMarshalStruct() {
	str := "{\"name\":\"carver\",\"age\":29,\"address\":\"beijing\"}"
	//定义一个原来的结构体实例
	var people People
	err := json.Unmarshal([]byte(str), &people)
	if err != nil {
		fmt.Println("unmarshal err=%v", err)
	}
	fmt.Println(people)
}

// json字符串反序列化为map
func TestUnMarshalMarshalMap() {
	str := "{\"address\":\"花果山\",\"age\":123,\"name\":\"孙悟空\"}"
	//定义一个map 	反序列化不用make，make操作被封装到 Unmarshal 函数中了
	var a map[string]interface{}
	err := json.Unmarshal([]byte(str), &a)
	if err != nil {
		fmt.Println("unmarshal err=%v", err)
	}
	fmt.Println(a)
}

// json字符串反序列化为切片
func TestUnMarshalSlice() {
	str := "[{\"address\":[\"beijing\",\"shanghai\"],\"age\":43,\"name\":\"carver\"}," +
		"{\"address\":\"tianjin\",\"age\":55,\"name\":\"carver1\"}]"
	//定义一个slice 	反序列化不用make，make操作被封装到 Unmarshal 函数中了
	var slice []map[string]interface{}
	err := json.Unmarshal([]byte(str), &slice)
	if err != nil {
		fmt.Println("unmarshal err=%v", err)
	}
	fmt.Println(slice)
}

注意：

• 在反序列化一个json字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型保持一致
• 程序获取的json字符串不用做其它处理