【Golang】go语言之json、YAML的序列化和反序列化

11.1 json序列化

Go语言中的序列化和反序列化是一种解码思路

可以将结构体进行序列化为JSON字符串格式，

注意：不是将类型转化为JSON，go语言没有JSON格式类型，

是将数据，转化为 JSON格式风格的数据，供其他语言使用，

比如说，python中，也没有json这种数据格式，把一串json导入到Python，打印它的类型，打印出来就是string字符串类型，将json转化成字典，就是将字符串转成字典

带入到go语言中也是一样的概念，只是go语言可以通过结构体去转化成json(序列化)，变成一种键值对的格式（也有不是键值对格式的json）

go语言序列化（结构体转json）和反序列化的实现方式：通过json.Marshal(person) person就是结构体实例化的数据，json.Unmarshal(jsondata)就是反序列化（结构体转json）

结构体转JSON

import (
	"encoding/json"
	"fmt"
)

type Myaccount struct {
	Name   string `json:"name"`
	PWD    string `json:"pwd"`
	Amount int    `json:"amount"`
}
func main() {
	account := Myaccount{"and", "123", 18}
	fmt.Println("打印一下：", account) // 打印一下： {and 123 18}
	// 序列化方法
	data1, _ := json.Marshal(account)
    fmt.Println("序列化后的data1:", string(data1)) // 序列化后的data1: {"name":"and","pwd":"123","amount":18}
	fmt.Printf("%T\n", data1) // 打印出来的类型是无符号8位整形[]uint8，无正负符号8位整形
	data2, _ := json.MarshalIndent(account, "", " ")// MarshalIndent带缩进

	fmt.Println("序列化后的data2=", string(data2))    // 序列化后的data2= {
 "name": "and",
 "pwd": "123",
 "amount": 18
}
	fmt.Printf("data2的格式是：%T\n", data2) // []uint8
// 反序列化方法，就用json.Unmarshal()方法
	var account2 Myaccount // 定义一个变量account2，类型是Myaccount结构体
	json.Ummarshal(data1,&account2)
	fmt.Println("account2=", account2)// account2={and 123 18} ,打印出来的就是结构体了
	fmt.Printf("%T\n", account2) // 类型就是main.Myaccount

}

// 再写一个
type MyScore struct {
	Name  string `json:"name"`
	Class string `json:"class"`
	Score int    `json:"score"`
}
func main() {
    TomScore := MyScore{"Tom", "2班", 99}
	fmt.Println("TomSocre=", TomScore)
	// 将TomScore进行序列化
	JsonTomScore, _ := json.Marshal(TomScore)
	fmt.Println("JsonTomScore=", string(JsonTomScore))
	// 优化缩进后的
	JsonTomScore2, _ := json.MarshalIndent(TomScore, "", " ")
	fmt.Println("JsonTomScore2=", string(JsonTomScore2))
	// 反序列化
	var tom MyScore
	json.Unmarshal(JsonTomScore, &tom)
	fmt.Println("tom=", tom)
}

序列化和反序列化，目前用到的是结构体类型数据转成json格式，和json格式转成结构体类型的数据

Yaml 序列化和反序列化（yaml与结构体互转）

• 思路和方式跟json的是一样的，只是用了一个库：**”gopkg.in/yaml.v3”**

import (
	"fmt"
	"gopkg.in/yaml.v3"
	"io/ioutil"
	"log"
)

type MyYAML struct {
	Name  string `yaml:"name"`
	Age   int    `yaml:"age"`
	Email string `yaml:"email,omitempty"`
}

func main() {
	// 序列化yaml 和序列化json一样的  yaml.Marshal
	YamlStruct := MyYAML{"andy", 11, "110@163.com"}
	fmt.Println("YamlStruct=", YamlStruct)
	YamlDate, _ := yaml.Marshal(YamlStruct)
	fmt.Println("YamlDate=", string(YamlDate))
	// 下面反序列化yaml,也是和json一样思路，yaml.UnMarshal
	// 不过在这之前你要有一个yaml文件，读取这个yaml文件后才能去打印出来
	yamlDataFile, err := ioutil.ReadFile("data.yml") // 读取yml文件
	if err != nil {
		log.Fatalf("Failed to read YAML file: %v", err)
	}
	var MyYamlStruct MyYAML
	err = yaml.Unmarshal(yamlDataFile, &MyYamlStruct) // 把数据赋值到结构体里，用指针，改变他的值
	if err != nil {
		log.Fatalf("Failed to unmarshal YAML: %v", err)
	}
	// 打印数据出来，
	fmt.Printf("Name: %s, Age: %d, Email: %s\n", MyYamlStruct.Name, MyYamlStruct.Age, MyYamlStruct.Email)
}