Go_JSON

json

• json（javascript object notation）是一种轻量级的数据交换格式。是目前主流的数据格式
• json易于机器解析和生成，有效地提高网络传输效率。通常程序在网络传输时会先将数据（结构体、map等）序列化成json字符串，到接收方得到json字符串时，在反序列化恢复成原来的数据类型（结构体、map等）
• 在json语言中，一切都是对象。任何数据类型都可以通过json来表示
• json通过键值对的方式来保存数据
• 应用场景
  

json数据在线解析

json序列化

• json序列化：将有key-value结构的数据类型（比如结构体、map、切片）序列化成json字符串的操作
• 演示结构体、map和切片的序列化（其他类型的序列化类似）
• 使用的json包函数：func Marshal(v interface{}) ([]byte, error)

package main
import (
	"fmt"
	"encoding/json"
)
type Monster struct{
	Name string
	Age int
	Birthday string
	Sal float64
	Skill string
}

func testStruct(){
	monster := Monster{
		Name: "牛魔王",
		Age: 800,
		Birthday: "1991-11-12",
		Sal: 888.88,
		Skill: "芭蕉扇",
	}
	data, err := json.Marshal(&monster)
	if err != nil{
		fmt.Println("序列化失败", err)
	}
	fmt.Printf("序列化的结果是：%v", string(data))
	} 
//将map进行序列化

func testMap(){
	//定义一个map
	var a map[string]interface{}
	//使用map需要先make
	a = make(map[string]interface{})
	a["name"]="红孩儿"
	a["age"]=200
	a["address"]="火云洞"
	data, err := json.Marshal(a)
	if err != nil{
		fmt.Println("序列化失败", err)
	}
	fmt.Printf("序列化的结果是：%v", string(data))
}
//对切片进行序列化
func testSlice(){
	var slice[]map[string]interface{}
	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"]="jack"
	m1["age"]="12"
	m1["address"]="北京"
	slice = append(slice, m1)
	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"]="luxi"
	m2["age"]="8"
	m2["address"]=[2]string{"上海","昆明"}
	slice = append(slice, m2)
	data, err := json.Marshal(slice)
	if err != nil{
		fmt.Println("序列化失败", err)
	}
	fmt.Printf("序列化的结果是：%v", string(data))

}

//对基本数据类型序列化
func testFloat64(){
	var num1 float64 = 2345.33
	//对num1进行序列化
	data, err := json.Marshal(num1)
	if err != nil{
		fmt.Println("序列化失败", err)
	}
	fmt.Printf("序列化的结果是：%v", string(data))
}

func main(){
	//演示将结构体、map、切片进行序列化
	testStruct()
	testMap()
	testSlice()
	testFloat64()
}

• 对于结构体的序列化，希望序列化后的json串的key值按照指定的标准显示，可以给结构体加一个tag标签

json反序列化

• json反序列化：将json字符串反序列化成对应的数据类型（比如结构体、map、切片）的操作
• func Unmarshal(data []byte, v interface{}) error
• 案例：将json字符串反序列化结构体、map和切片

package main
import (
	"fmt"
	"encoding/json"
)
type Monster struct{
	Name string  //反射机制
	Age int  
	Birthday string
	Sal float64
	Skill string
}

//演示将json字符串，反序列化结构体
func unmarshalStruct(){
	//真实开发中str通过网络传输获取到的，或者是读取文件获取到的
	str := "{\"Name\":\"牛魔王\",\"Age\":800,\"Birthday\":\"1991-11-12\",\"Sal\":888.88,\"Skill\":\"芭蕉扇\"}"
	//定义一个monster实例
	var monster Monster
	err := json.Unmarshal([]byte(str), &monster)
	if err != nil{
		fmt.Printf("unmarshal err = %v\n", err)
	}
	fmt.Printf("反序列化后 monster=%v monster.Name=%v\n", monster, monster.Name)
}

//演示将json字符串，反序列化map
func unmarshalMap(){
	//真实开发中str通过网络传输获取到的，或者是读取文件获取到的
	str := "{\"address\":\"火云洞\",\"age\":200,\"name\":\"红孩儿\"}"
	//定义一个map
	var a map[string]interface{}

	//反序列化
	//注意：反序列化map时，不需要map，因为make操作被封装到unmarshal函数里了
	err := json.Unmarshal([]byte(str), &a)
	if err != nil{
		fmt.Printf("unmarshal err = %v\n", err)
	}
	fmt.Printf("反序列化后 a=%v", a)
}

//演示将json字符串，反序列化slice
func unmarshalSlice(){
	//真实开发中str通过网络传输获取到的，或者是读取文件获取到的
	str := "[{\"address\":\"北京\",\"age\":\"12\",\"name\":\"jack\"},"+
	"{\"address\":[\"上海\",\"昆明\"],\"age\":\"8\",\"name\":\"luxi\"}]"
	//定义一个slice
	var slice []map[string]interface{}

	//反序列化
	//注意：反序列化map时，不需要map，因为make操作被封装到unmarshal函数里了
	err := json.Unmarshal([]byte(str), &slice)
	if err != nil{
		fmt.Printf("unmarshal err = %v\n", err)
	}
	fmt.Printf("反序列化后 a=%v", slice)
}
func main(){
	unmarshalStruct()
	unmarshalMap()
	unmarshalSlice()
}

• 注意：在反序列化一个json字符串时，要确保反序列化后的数据类型和原来的序列化前的数据类型一致
• 如果json字符串是通过程序获取到的，则不需要再对 " 转义处理