JSON序列化

[toc]

😶‍🌫️go语言官方编程指南：https://golang.org/#open in new window

go语言的官方文档学习笔记很全，推荐去官网学习

😶‍🌫️我的学习笔记：github: https://github.com/3293172751/golang-rearnopen in new window

区块链技术（也称之为分布式账本技术），是一种互联网数据库技术，其特点是去中心化，公开透明，让每一个人均可参与的数据库记录

❤️💕💕关于区块链技术，可以关注我，共同学习更多的区块链技术。博客http://nsddd.topopen in new window

JSON

JSON🚸

JSON: JavaScript Object Notation（JavaScript 对象标记法）。

JSON 是一种存储和交换数据的语法。

JSON 是通过 JavaScript 对象标记法书写的文本。

交换数据

当数据在浏览器与服务器之间进行交换时，这些数据只能是文本。

JSON 属于文本，并且我们能够把任何 JavaScript 对象转换为 JSON，然后将 JSON 发送到服务器。

我们也能把从服务器接收到的任何 JSON 转换为 JavaScript 对象。

以这样的方式，我们能够把数据作为 JavaScript 对象来处理，无需复杂的解析和转译。

json从2001开始推广使用，目前已经成为主流的数据格式

发送数据

如果您的数据存储在 JavaScript 对象中，您可以把该对象转换为 JSON，然后将其发送到服务器。

var myObj = { name:"Bill Gates",  age:62, city:"Seattle" };
var myJSON =  JSON.stringify(myObj);
window.location = "demo_json.php?x=" + myJSON;

接收数据

如果您以 JSON 格式接收到数据，您能够将其转换为 JavaScript 对象：

var myJSON = '{ "name":"Bill Gates",  "age":62, "city":"Seattle" }';
var myObj = JSON.parse(myJSON);
document.getElementById("demo").innerHTML = myObj.name;

存储数据

在存储数据时，数据必须是某种具体的格式，并且无论您选择在何处存储它，文本永远是合法格式之一。

JSON 让 JavaScript 对象存储为文本成为可能。

把数据存储在本地存储中

//存储数据：
myObj = { name:"Bill Gates",  age:62, city:"Seattle" };
myJSON =  JSON.stringify(myObj);
localStorage.setItem("testJSON", myJSON);

//接收数据：
text = localStorage.getItem("testJSON");
obj =  JSON.parse(text);
document.getElementById("demo").innerHTML = obj.name;

总结

在js中，一切都是对象，因此任何的数据类型都可以用json来表示
js中可以通过键值对来表示数据
js扩展性特别好

JSON数据在线解析

JSON在线解析

在我们做复杂的数据的时候可以选择

🖱️解析网址地址open in new window

JSON序列化

结构体序列化

jaon序列化是指将现有的key-value结构的数据结构（结构体，map，切片）序列化为json字符串

/*************************************************************************
    > File Name: json.go                                                                                                                               
    > Author: smile
    > Mail: 3293172751nss@gmail.com 
    > Created Time: Sun 13 Mar 2022 01:48:07 PM CST
 ************************************************************************/
package main
import(
    "fmt"
    "encoding/json"
)
type M struct{
    Name string 
    Age int
    Birthday string
    sal float64
    skill string
}

func test(){
    m := M{
        Name:"牛魔王",
        Age:20,
        Birthday:"2011-11-11",
        Sal:800000.00,
        Skill:"牛魔权",
    }     //一定要是大写
    //将M序列化
    data ,err := json.Marshal(&m)  //使用json中的Marshal方法
    if err != nil{
        fmt.Printf("序列化失败:err:%v\n",err)
    }
    //输出序列化后的结果
    fmt.Printf("序列化后的结果:%v",string(data))         //字符串需要转化
}

func main(){
    test()    
}

编译：

[root@mail golang]# go run json.go 
序列化后的结果:{"Name":"牛魔王","Age":20,"Birthday":"2011-11-11","Sal":800000,"Skill":"牛魔权"}

在www.json.cn上验证

{
    "Name":"牛魔王",
    "Age":20,
    "Birthday":"2011-11-11",
    "Sal":800000,
    "Skill":"牛魔权"
}

将map进行序列化

func testMap(){
	var a map[string]inferface{}
    //key为字符串，值为任意类型
    //使用map先make
    a = make(map[string]interface{})
    a["name"]="红孩儿"
    a["age"]=19
    a["adress"]="wuhan"
    
    data ,err := json.Marshal(a)  //使用json中的Marshal方法
    //map是引用传递，所以不需要取地址符号
    if err != nil{
    	fmt.Printf("序列化失败:err:%v\n",err)
    }
    //输出序列化后的结果
    fmt.Printf("序列化后的结果:%v",string(data))         //字符串需要转化
}

编译和序列化

序列化后的结果:{"adress":"wuhan","age":19,"name":"红孩儿"}
{
    "adress":"wuhan",
    "age":19,
    "name":"红孩儿"
}

对切片序列化

funcSlice(){
//复杂化，一个切片中有很多map
    var slice  []map[string]interface{}
    var s map[string]interface{}
    //使用map先make
    s = make(map[string]interface{})
    s["name"]="张三"
    s["age"]=3
    s["adress"]="wuhan"
    slice = append(slice,s)
    s = make(map[string]interface{})
    
    var u map[string]interface{}
    u = make(map[string]interface{})
    u["name"]="张三"
    u["age"]=3
    u["adress"]="wuhan"
    slice = append(slice,u)
    
    data ,err := json.Marshal(slice)  //使用json中的Marshal方法
    //map是引用传递，所以不需要取地址符号
    if err != nil{
    	fmt.Printf("序列化失败:err:%v\n",err)
    }
    //输出序列化后的结果
    fmt.Printf("序列化后的结果:%v\n",string(data))         //字符串需要转化    
}

普通类型序列化

func testnum(){
	ver num float64 = 12313.122
    data ,err := json.Marshal(num)  //使用json中的Marshal方法
    if err != nil{
    	fmt.Printf("序列化失败:err:%v\n",err)
    }    
}

序列化代码

/*************************************************************************
    > File Name: json.go
    > Author: smile
    > Mail: 3293172751nss@gmail.com 
    > Created Time: Sun 13 Mar 2022 01:48:07 PM CST
 ************************************************************************/
package main
import(
    "fmt"
    "encoding/json"
)
type M struct{
    Name string 
    Age int 
    Birthday string
    Sal float64
    Skill string
}

func test(){
    m := M{
        Name:"牛魔王",
        Age:20,
        Birthday:"2011-11-11",
        Sal:800000.00,
        Skill:"牛魔权",
    }   
    //将M序列化
    data ,err := json.Marshal(&m)  //使用json中的Marshal方法
    if err != nil{
        fmt.Printf("序列化失败:err:%v\n",err)
    }   
    //输出序列化后的结果
    fmt.Printf("结构体序列化后的结果:%v\n",string(data))         //字符串需要转化
    fmt.Println()
}
func testMap(){
    var a map[string]interface{}
    //key为字符串，值为任意类型
    //使用map先make
    a = make(map[string]interface{})
    a["name"]="红孩儿"
    a["age"]=19
    a["adress"]="wuhan"
    
    data ,err := json.Marshal(a)  //使用json中的Marshal方法
    //map是引用传递，所以不需要取地址符号
    if err != nil{
        fmt.Printf("序列化失败:err:%v\n",err)
    }   
    //输出序列化后的结果
    fmt.Printf("map序列化后的结果:%v\n",string(data))         //字符串需要转化
    fmt.Println()
}
func testSlice(){
//复杂化，一个切片中有很多map
    var slice []map[string]interface{}
    var s map[string]interface{}
    //使用map先make
    s = make(map[string]interface{})
    s["name"]="张三"
    s["age"]=3
    s["adress"]="wuhan"
    slice = append(slice,s)

    var u map[string]interface{}
    u = make(map[string]interface{})
    u["name"]="张三"
    u["age"]=3
    u["adress"]="wuhan"
    slice = append(slice,u)

    data ,err := json.Marshal(slice)  //使用json中的Marshal方法
    //map是引用传递，所以不需要取地址符号
    if err != nil{
        fmt.Printf("序列化失败:err:%v\n",err)
    }   
    //输出序列化后的结果
    fmt.Printf("slice切片序列化后的结果:%v\n",string(data))         //字符串需要转化
    fmt.Println()
}
func testNum(){
    var num float64 = 12313.122
    data ,err := json.Marshal(num)  //使用json中的Marshal方法
    if err != nil{
        fmt.Printf("序列化失败:err:%v\n",err)
    }   
    fmt.Printf("普通数字序列化后的结果:%v\n",string(data))         //字符串需要转化
    fmt.Println()                                                                                                  
}
func main(){
    test()    
    testMap()
    testSlice()
    testNum()
}

编译

[root@mail golang]# go run json.go 
结构体序列化后的结果:[{"Name":"牛魔王","Age":20,"Birthday":"2011-11-11","Sal":800000,"Skill":"牛魔权"}

map序列化后的结果:{"adress":"wuhan","age":19,"name":"红孩儿"}

slice切片序列化后的结果:[[{"adress":"wuhan","age":3,"name":"张三"},{"adress":"wuhan","age":3,"name":"张三"}]

普通数字序列化后的结果:12313.122

www.json.cn序列化：

[
    {
        "Name":"牛魔王",
        "Age":20,
        "Birthday":"2011-11-11",
        "Sal":800000,
        "Skill":"牛魔权"
    },
    {
        "adress":"wuhan",
        "age":19,
        "name":"红孩儿"
    },
    [
        {
            "adress":"wuhan",
            "age":3,
            "name":"张三"
        },
        {
            "adress":"wuhan",
            "age":3,
            "name":"张三"
        }
    ],
    12313.122
]

json的反序列化

type M struct{
    Name string `json: "姓名"` 
    Age int   `json : "年龄"`
    Birthday string   `json : "出生`
    Sal float64		`json : "战斗力"`
    Skill string	`json : "绝招"`
}

效果

结构体序列化后的结果:{"姓名":"牛魔王","年龄":20,"Birthday":"2011-11-11","战斗力":800000,"绝招":"牛魔权"}

因为在type中的字段需要首字母大写，否则挎包调用无法调用

json.Unmarshal([]byte(str),&monster)       //反序列化

案例

package main
import (
	"fmt"
	"encoding/json"
)

//定义一个结构体
type Monster struct {
	Name string  
	Age int 
	Birthday string //....
	Sal float64
	Skill string
}


//演示将json字符串，反序列化成struct
func unmarshalStruct() {
	//说明str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
	str := "{\"Name\":\"牛魔王~~~\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"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)

}
//将map进行序列化
func testMap() string {
	//定义一个map
	var a map[string]interface{}
    
	//使用map,需要make
	a = make(map[string]interface{})
	a["name"] = "红孩儿~~~~~~"
	a["age"] = 30
	a["address"] = "洪崖洞"

	//将a这个map进行序列化
	//将monster 序列化
	data, err := json.Marshal(a)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
	}
	//输出序列化后的结果
	//fmt.Printf("a map 序列化后=%v\n", string(data))
	return string(data)

}

//演示将json字符串，反序列化成map
func unmarshalMap() {
	//str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
	str := testMap()
	//定义一个map
	var a map[string]interface{} 

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

}

//演示将json字符串，反序列化成切片
func unmarshalSlice() {
	str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," + 
		"{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
	//当一个字符串很长的时候，换行可以使用`+`进行字符串的拼接
	//定义一个slice
	var slice []map[string]interface{}
	//反序列化，不需要make,因为make操作被封装到 Unmarshal函数
	err := json.Unmarshal([]byte(str), &slice)
	if err != nil {
		fmt.Printf("unmarshal err=%v\n", err)
	}
	fmt.Printf("反序列化后 slice=%v\n", slice)
}

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

注意以下四点：

反序列化map,不需要make,因为make操作被封装到 Unmarshal函数

如果是程序中读取的字符串，是不需要加\转移字符的
当一个字符串很长的时候，换行可以使用+进行字符串的拼接
反序列化和序列化的类型应该保持一致，不能篡改

END 链接

Ⓜ️回到目录🏠
🫵参与贡献💞❤️‍🔥💖open in new window)

# JSON序列化

# JSON

# 交换数据

# 发送数据

# 接收数据

# 存储数据

# 总结

# JSON数据在线解析

# JSON序列化

# 结构体序列化

# 将map进行序列化

# 对切片序列化

# 普通类型序列化

# 序列化代码

# json的反序列化

# END 链接

JSON序列化

JSON

交换数据

发送数据

接收数据

存储数据

总结

JSON数据在线解析

JSON序列化

结构体序列化

将map进行序列化

对切片序列化

普通类型序列化

序列化代码

json的反序列化

END 链接