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)
}
输出
