【go】【json】json格式初体验及序列化

1.json是一种轻量级的数据交换格式
JavaScript object notation

通常网络传输过程中，把数据（结构体、map）序列化成json字符串。再反序列化成原来的数据类型

2.json用键值对保存数据
key写在前面用“”包裹，用：分割，再跟着value
键值对之间用逗号隔开
每一个数据对象用{}包裹

json检测网站
json.cn

3.序列化
将有key-value结构的数据类型（结构、map、切片）序列化成json字符串

注意结构体字段必须！！大写
不然不能导出，json包用不了你的数据

type Monster struct{
	Name string
	Age int
	Birthday string
	Skill string
	Sal float64
}

func testStruct() {
	monster := Monster{
		Name : "wukong",
		Age : 10000,
		Birthday : "322-4-2",
		Skill : "fly",
		Sal : 23,
	}
	//将monster序列化
	//Marshal函数返回v interface{}的json序列化编码
	//其可以接收任意类型 若失败返回error
	data, err := json.Marshal(&monster)
	if err != nil {
		fmt.Printf("序列化失败 err =%v\n", err)
	}
	//输出序列化后的结果
	fmt.Printf("monster: %v\n", string(data))
}

//将map序列化
func testMap() {
	var a map[string]interface{}
	//使用map 先make
	a = make(map[string]interface{})
	a["name"] = "spider"
	a["age"] = 33
	a["skill"] = "swim"
	//map本身是引用类型
	data, err := json.Marshal(a)
	if err != nil {
		fmt.Printf("序列化失败 err =%v\n", err)
	}
	//输出序列化后的结果
	//可以看到map的存储是无序的
	fmt.Printf("a: %v\n", string(data))
}

//slice序列化
func testSlice() {
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "theShy"
	m1["age"] = 20
	m1["address"] = "shanghai"
	slice = append(slice, m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "rookie"
	m2["age"] = 22
	m2["address"] = [2]string{"shanghai", "wuhu"}
	slice = append(slice, m2)
	data, err := json.Marshal(slice)
	if err != nil {
		fmt.Printf("序列化失败 err =%v\n", err)
	}
	//输出序列化后的结果
	fmt.Printf("slice:  %v\n", string(data))
}

//基本类型序列化 实际上没什么意义
func testFloat64(){
	n1 := 1313.12
	data, err := json.Marshal(n1)
	if err != nil {
		fmt.Printf("序列化失败 err =%v\n", err)
	}
	//输出序列化后的结果
	fmt.Printf("monster： %v\n", string(data))
}

func main(){
	testStruct()
	testMap()
	testSlice()
	testFloat64()
}

4.使用tag序列化

type Monster struct{
	Name string `json:"name"` //反射机制
	Age int `json:"monster_age"`
	Birthday string
	Skill string
	Sal float64
}

字段本身必须大写，可以特别指定序列化后的名字，用tag

5.反序列化
将json字符串 反序列化为对应的类型

反序列化后 最好保证 与序列化前类型一致
如果是不同的结构，但是字段完全一样，其实也能反序列化成功

type Monster struct{
	Name string `json:"name"` //反射机制
	Age int `json:"monster_age"`
	Birthday string
	Skill string
	Sal float64
}

func unmarshalStruct() {
	//str 通过网络传输得到 或者读取文件得到
	str := "{\"Name\":\"wukong\",\"Age\":10000,\"Birthday\":\"322-4-2\",\"Skill\":\"fly\",\"Sal\":23}"
	var monster Monster
	err := json.Unmarshal([]byte(str), &monster)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("monster = %v\n", monster)
	fmt.Println(monster.Name)
}

func unmarshalMap() {
	//str 通过网络传输得到 或者读取文件得到
	str := "{\"Name\":\"wukong\",\"Age\":10000,\"Birthday\":\"322-4-2\",\"Skill\":\"fly\",\"Sal\":23}"
	var a map[string]interface{}
	//反序列化时不需要make
	//make被封装到unmarshal中
	err := json.Unmarshal([]byte(str), &a)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("a = %v\n", a)
	fmt.Println(a["Sal"])
}

func unmarshalSlice() {
	//str 通过网络传输得到 或者读取文件得到
	str := "[{\"Name\":\"wukong\",\"Age\":10000,\"" +
		"Birthday\":\"322-4-2\",\"Skill\":\"fly\",\"Sal\":23}]"
	var slice []map[string]interface{}
	//反序列化时不需要make
	//make被封装到unmarshal中
	err := json.Unmarshal([]byte(str), &slice)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("slice = %v\n", slice)
	fmt.Println(slice[0])
}

func main(){
	unmarshalStruct()
	unmarshalMap()
	unmarshalSlice()
}