Go 语言 序列化、反序列化的使用
Go 语言 序列化、反序列化的使用
一、结构体的操作:
1. 结构体序列化：
package main
import (
"encoding/json"
"fmt"
)
// 定义一个结构体
type Monster struct {
Name string
Age int
Birthday string
Sal float64
}
// 演示结构体进行序列化
func testStruct () {
monster := Monster{Name:"铁牛", Age: 18, Birthday: "2020-02-02", Sal: 1.00}
// 将结构体Monster进行序列化
data, err := json.Marshal(&monster)
if err != nil{
fmt.Printf("序列化错误 err=%v", err)
}
// 输出序列化后的结果
fmt.Printf("monster 序列化后的=%v", string(data)) // 返回的是[]byte切片, 需要转换string类型
}
func main() {
// 演示将结构体进行序列化
testStruct()
}
使用
json.Marshal(*point)：
- 参数是指针类型；
- 返回值是[]byte切片, 需要转换string;
序列化时，给字段起别名的用法：
// 在定义结构体的时候, 需要进行 反射机制
type Monster struct {
Name string `json:"monster_name"` // 反射机制
Age int `json:"monster_age"`
Birthday string `json:"birthday"`
Sal float64
}
注意：格式，严格匹配, 不能有多余的空格之类
2.结构体反序列化：
package main
import (
"encoding/json"
"fmt"
)
// 定义一个结构体
type Monster struct {
Name string
Age int
Birthday string
Sal float64
}
// 将json 字符串, 反序列化struct
func unmarshalStruct () {
jsonStr := "{\"Name\":\"铁牛\", \"Age\":18,\"Birthday\":\"2020-02-02\",\"Sal\":1}"
// 定义一个Monster实例
var monster Monster
err := json.Unmarshal([]byte(jsonStr), &monster)
if err != nil{
fmt.Printf("unarshar err=%v", err)
}
fmt.Printf("反序列化后 monster=%v\n", monster)
}
func main() {
// 定义一个反序列化
unmarshalStruct()
}
使用json.Unmarshal()将 json 数据格式反序列化
二、map操作：
1.map序列化：
package main
import (
"encoding/json"
"fmt"
)
// 将map进行序列化
func testMap(){
// 定义一个Map, key 是String 类型 值是interface类型
var myMap map[string]interface{}
// 使用map之前, 需要make 类型
myMap = make(map[string]interface{})
myMap["name"] = "铁牛"
myMap["age"] = 18
myMap["sal"] = 10.00
// 将myMap进行序列化
data, err := json.Marshal(myMap) // 因为map就是引用类型, 所以前面不需要加&
if err != nil{
fmt.Printf("map序列化的错误 err=%v", err)
}
fmt.Printf("map 序列化后=%v", string(data))
}
func main () {
// map 进行序列化
testMap()
}
2.map反序列化：
package main
import (
"encoding/json"
"fmt"
)
// 将字符串反序列化成Map
func unmarshalMap() {
jsonStr := "{\"age\":18, \"name\": \"铁牛\", \"sal\":10}"
// 定义一个map
var myMap map[string]interface{}
// 反序列话, 不需要进行make 操作
err := json.Unmarshal([]byte(jsonStr), &myMap)
if err != nil{
fmt.Printf("unmarshl err=%v", err)
}
fmt.Printf("反序列化 map:%v", myMap)
}
func main () {
unmarshalMap()
}
注意：反序列化map，不需要make，因为make操作被封装到 Unmarshal函数
三、切片(slice):
1.切片序列化：
package main
import (
"encoding/json"
"fmt"
)
// 演示对切片进行序列化
func testSlice () {
var mySlice []map[string]interface{}
var m1 map[string]interface{}
//使用map 前需要进行make
m1 = make(map[string]interface{})
m1["name"] = "jack"
m1["age"] = 15
mySlice = append(mySlice, m1)
var m2 map[string]interface{}
m2 = make(map[string]interface{})
m2["name"] = "tom"
m2["age"] = 18
mySlice = append(mySlice, m2)
data, err := json.Marshal(mySlice) // slice 也是引用类型 不需要特意加&
if err != nil{
fmt.Printf("序列化错误 err=%v", err)
}
fmt.Printf("slice 序列化:%v", string(data))
}
func main (){
// 运行切片序列化
testSlice()
}
2.切片反序列化：
package main
import (
"encoding/json"
"fmt"
)
// 将json字符串, 反序列化成切片
func unmarshalSlice () {
jsonStr := "[{\"age\":15, \"name\": \"jack\"},{\"age\": 18, \"name\": \"tom\"}]"
// 定义一个slice
var mySlice []map[string]interface{}
// 反序列化slice, 也不需要操作make
err := json.Unmarshal([]byte(jsonStr), &mySlice)
if err != nil{
fmt.Printf("错误信息 err=%v", err)
}
fmt.Printf("切片反序列化后:%v", mySlice)
}
func main() {
unmarshalSlice()
}
同样slice反序列化也不需要make操作，Unmarshal()做了处理
四、总结：
-
在反序列化一个json字符串时，
确保反序列化后的数据类型和原来序列化类型一致。 -
序列化使用：
data, err := json.Marshal(引用类型) if err != nil{ fmt.Printf("错误 err=%v", err) } fmt.Printf("序列化后=%v", string(data)) // 返回的是byte[] 需要转换string -
反序列化使用：
err := json.Unmarshal([]byte(jsonStr), 引用类型) if err != nil{ fmt.Printf("错误信息 err=%v", err) } fmt.Printf("反序列化后:%v", mySlice) // 反序列化不需要make操作, 需要将string类型转换成[]byte类型