Json 编解码

JSON概述

1.JSON(JavaScript Object Notation):
轻量级的数据交换格式,一种数据结构化交互的标准协议,比XML易于阅读和编写、易于解析和生成。

2.主要功能:
json是客户端和服务端的交互传递数据,最通用的并且也是最流行的格式
有效提升网络传输效率,程序在网络传输时会先将数据(如结构体、map等)序列化成json字符串,
到接收方接收到json字符串时,再反序列化恢复成原来的数据类型

JSON数据格式

任何数据类型都可以通过JSON来表示，如字符串、数字、对象、数组、map、结构体等。数据格式：JSON键值对
在www.json.cn可以在线转换和检测json字符串

{"name":"monkey"}

{"name":"monkey","age":10,"address":["上海","成都"]}

[{"name":"monkey1","age":11,"address":["上海","成都"]},{"name":"monkey2","age":12,"address":["北京","成都"]}]

JSON序列化（编码）

1.json.Marshal

将有key-value结构的数据类型（如结构体、切片、map）序列化成json字符串。使用encoding/json包中的Marshal()函数。函数原型

func Marshal(v interface{})([]byte,error)

编码一个结构体时，结构体中只有字段名首字母为大写的成员才会被编码，而首字母小写的成员会被忽略。
结构体字段后面允许使用反引号声明成员的Tag，用于说明成员的元信息

结构体、切片、map、基本数据类型的编码

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name string `json:"monster_name"`//反射机制
	Age int `json:"monster_age"`
	Birthday string `json:"monster_birthday"`
	Sal float64
	Skill string
}
func testStruct(){
	monster := Monster{
		Name:"monkey",
		Age:18,
		Birthday:"2000-1-1",
		Sal:100.0,
		Skill:"吃",
		}
		xu,err := json.Marshal(&monster)
		if err!= nil{
			fmt.Println("结构体序列化失败！err: \n",err)
			return
		}
		fmt.Println("结构体序列化后是：",string(xu))
}
func testMap(){
	//注意！使用map必须要make
	mymap := make(map[string]interface{})
	mymap["Name"] = "monkey2"
	mymap["Age"] = 17
	mymap["Skill"] = "跑"
	mymap["Birthday"] = "1999-1-1"
	 xu,err := json.Marshal(mymap)
	 if err != nil{
	 	fmt.Println("map序列化失败！err：",err)
		 return
	 }
	 fmt.Println("map序列化后是：",string(xu))
}
func testSlice(){
	//使用切片不需要make
	//切片里面多个map
	var myslice []map[string]interface{}
	//myslice := make([]map[string]interface{},5)
	map1 := make(map[string]interface{})
	map1["Name"] = "monkey1"
	map1["Age"] = 16
	map1["address"] = [...]string{"上海","成都"}
	myslice = append(myslice,map1)
	map2 := make(map[string]interface{})
	map2["Name"] = "monkey2"
	map2["Age"] = 26
	map2["address"] = [...]string{"巴黎","瑞士"}
    myslice = append(myslice,map2)
	xu,err := json.Marshal(myslice)
	if err != nil{
		fmt.Println("slice序列化失败！err；",err)
		return
	}
	fmt.Println("slice序列化后是：",string(xu))
}
func testNormal(){
	 var i int
	 i = 10
	 xu,err := json.Marshal(i)
	 if err != nil{
	 	fmt.Println("int型数据序列化失败！err：",err)
		 return
	 }
	 fmt.Println("int型数据序列化后是：",string(xu))
}
func main() {
	//结构体、map、切片序列化
	testStruct()
	testMap()
	testSlice()
	testNormal()
}

2.json.Encoder

JSON反序列化（解码）

反序列化：序列化的逆向操作，使用encoding/json包中的Unmarshal()函数。函数原型

func Unmarshal(data []byte,v interface{}) error

结构体、map、slice的解码

package main

import (
	"encoding/json"
	"fmt"
)
type Monster struct {
	Name string
	Age int
	Birthday string
	Sal float64
	Skill string
}
func unmarshalStruct(){
       str := "{\"Name\":\"monkey\",\"Age\":18,\"Birthday\":\"2000-1-1\",\"Sal\":100,\"Skill\":\"吃\"}"
       var monster Monster
       //这里必须用引用传递,只有引用传递才可以改变monster的值
       err := json.Unmarshal([]byte(str),&monster)
       if err != nil{
       	   fmt.Println("结构体反序列化失败！err：",err)
		   return
	   }
	   fmt.Println("结构体反序列化后是：",monster)
}
func unmarshalMap(){
     str := "{\"Age\":17,\"Birthday\":\"1999-1-1\",\"Name\":\"monkey2\",\"Skill\":\"跑\"}"
     //反序列化不用make一个map
     var map1 map[string]interface{}
     err := json.Unmarshal([]byte(str),&map1)
	if err != nil{
		fmt.Println("map反序列化失败！err：",err)
		return
	}
	fmt.Println("map反序列化后是：",map1)

}
func unmarshalSlice(){
     str := " [{\"Age\":16,\"Name\":\"monkey1\",\"address\":[\"上海\",\"成都\"]},"+
     	"{\"Age\":26,\"Name\":\"monkey2\",\"address\":[\"巴黎\",\"瑞士\"]}]"
     var myslice []map[string]interface{}
     err := json.Unmarshal([]byte(str),&myslice)
	if err != nil{
		fmt.Println("slice反序列化失败！err：",err)
		return
	}
	fmt.Println("slice反序列化后是：",myslice)
}
func main() {
    unmarshalStruct()
    unmarshalMap()
    unmarshalSlice()
}

2.json.Decoder

未完待续…