【go】序列化与反序列化

1 序列化

struct，map，slice，基本数据类型 -> json（string）

type Person struct {
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Sex   bool   `json:"sex"`
	Skill string `json:"skill"`
}

func Marshal() {

	// 1.结构体序列化
	// 赋值方式1
	person := Person{
		Name:  "Amy",
		Age:   10,
		Sex:   false,
		Skill: "swimming",
	}
	// 注意传的是地址
	data1, err := json.Marshal(&person)
	if err != nil {
		fmt.Println("序列化失败，err=", err)
		return
	}
	//输出序列化结果
	fmt.Println("结构体序列化后，data=", string(data1), reflect.TypeOf(string(data1)))

	// 赋值方式2
	var person1 = Person{}
	person1.Name = "Mike"
	person1.Age = 12
	person1.Sex = true
	person1.Skill = "football"
	data1, err = json.Marshal(&person)
	if err != nil {
		fmt.Println("序列化失败，err=", err)
		return
	}
	//输出序列化结果
	fmt.Println("结构体序列化后，data=", string(data1), reflect.TypeOf(string(data1)))

	// 2.map字典序列化
	//使用map，需要make
	m := make(map[string]interface{})
	m["name"] = "Mike"
	m["age"] = 12
	m["sex"] = true
	m["skill"] = "football"
	//将m序列化
	data2, err := json.Marshal(m)
	if err != nil {
		fmt.Println("序列化失败，err=", err)
		return
	}
	//输出序列化结果
	fmt.Println("map序列化后，data=", string(data2), reflect.TypeOf(string(data2)))

	// 3.[]map切片序列化
	var sm []map[string]interface{}
	//使用map，需要make
	m1 := make(map[string]interface{})
	m1["name"] = "lala"
	m1["age"] = 2
	m1["sex"] = false
	m1["skill"] = "ball"

	m2 := make(map[string]interface{})
	m2["name"] = "dingding"
	m2["age"] = 4
	m2["sex"] = true
	m2["skill"] = "hat"

	//将m1和m2放到切片中
	sm = append(sm, m1)
	sm = append(sm, m2)

	//将切片序列化
	data3, err := json.Marshal(sm)
	if err != nil {
		fmt.Println("序列化失败，err=", err)
		return
	}
	//输出序列化结果
	fmt.Println("[]map序列化之后，data=", string(data3), reflect.TypeOf(string(data3)))

	// 基本数据类型序列化
	var f float64 = 66.66
	data4, err := json.Marshal(f)
	if err != nil {
		fmt.Println("序列化失败，err=", err)
		return
	}
	//输出序列化结果
	fmt.Println("float序列化之后，data=", string(data4), reflect.TypeOf(string(data4)))
}

输出

2 反序列化

struct，map，slice，基本数据类型 <- json（string）

type Person struct {
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Sex   bool   `json:"sex"`
	Skill string `json:"skill"`
}

func UnMarshal() {
	// 1.结构体反序列化
	str := "{\"age\":22,\"skill\":\"reading\",\"name\":\"lisi\",\"sex\":false}"
	fmt.Println(str, reflect.TypeOf(str))
	var person Person
	err := json.Unmarshal([]byte(str), &person)
	if err != nil {
		fmt.Println("反序列化失败，err = %v", err)
	}
	fmt.Println("struct,person = %v", person, reflect.TypeOf(person))

	// 2.map反序列化
	var p map[string]interface{}
	err = json.Unmarshal([]byte(str), &p)
	if err != nil {
		fmt.Println("反序列化失败，err = %v", err)
	}
	fmt.Println("map,person = %v", person)

	// 3.slice反序列化
	str1 := "[{\"age\":22,\"skill\":\"reading\",\"name\":\"lisi\",\"sex\":false}]"
	var sp []map[string]interface{}
	err = json.Unmarshal([]byte(str1), &sp)
	if err != nil {
		fmt.Println("反序列化失败，err = %v", err)
	}
	fmt.Println("slice,person = %v", person)
}

输出