go encoding/json库详解

 

 

序列化与反序列化 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package main
  
import (
    "encoding/json"
    "fmt"
)
  
//JSON的序列化
//将结构体构成数据,并转JSON
//将map[string]interface{}构成数据,并转JSON
//使用map切片构成数据,并转JSON
  
//json.cn
//将结构体构成数据,并转JSON
//使用Man 结构体构成数据,并转为json
type Man struct{
    Name string
    Age int
    Hobby []string
    Sex bool
}
func maina1(){
    person := Man{"liyi",20,[]string{"唱歌","跳舞"},true}
    bytes,err := json.Marshal(person)
    if err != nil{
        fmt.Println("序列化失败,err=",err)
        return
    }else{
        fmt.Println("序列化成功,err=",err)
        fmt.Println(string(bytes))
    }
}
  
//将map[string]interface{}构成数据,并转JSON
//这里interface{}代表任意数据类型
func maina2(){
    dataMap := make(map[string]interface{})
    dataMap["name"] ="liyi"
    dataMap["age"] = 20
    dataMap["hobby"] = []string{"唱歌","跳舞"}
    dataMap["sex"] = true
    bytes,err := json.Marshal(dataMap)
    if err != nil{
        fmt.Println("序列化失败,err=",err)
        return
    }else{
        fmt.Println("序列化成功,err=",err)
        fmt.Println(string(bytes))
    }
}
  
  
  
//使用map切片构成数据,并转JSON
func maina3(){
    dataMap1 := make(map[string]interface{})
    dataMap1["name"] ="liyi"
    dataMap1["age"] = 20
    dataMap1["hobby"] = []string{"唱歌","跳舞"}
    dataMap1["sex"] = true
  
    dataMap2 := make(map[string]interface{})
    dataMap2["name"] ="linging"
    dataMap1["age"] = 21
    dataMap1["hobby"] = []string{"打炮"}
    dataMap1["sex"] = true
  
    dataMap3 := make(map[string]interface{})
    dataMap3["name"] ="yiyi"
    dataMap3["age"] = 18
    dataMap3["hobby"] = []string{"学习"}
    dataMap3["sex"] = true
  
    dataSlice := make([]map[string]interface{}, 0)
    dataSlice = append(dataSlice,dataMap1,dataMap2,dataMap3)
    bytes,err := json.Marshal(dataSlice)
    if err != nil{
        fmt.Println("序列化失败,err=",err)
        return
    }else{
        fmt.Println("序列化成功")
        fmt.Println(string(bytes))
    }
}
  
  
//JSON的反序列化
//将json数据转为map
//将json数据转为结构体
//将json数据转换为map切片
//将json数据转为结构体切片
  
//将json数据转为map
func maina4(){
    //json数据
    jsonStr := `{"Name":"liyi","Age":18,"Hobby":["抽烟","喝酒"],"sex":true}`
    //将json数据转为字节数据
    jsonbytes := []byte(jsonStr)
    dataMap := make(map[string]interface{})
  
    err := json.Unmarshal(jsonbytes,&dataMap)
    if err != nil {
        fmt.Println("反序列化失败,err=",err)
    }
    fmt.Println(dataMap)
}
//将json数据转为结构体
func maina5(){
    type Man struct{
        Name string
        Age int
        Hobby []string
        Sex bool
    }
    //json数据
    jsonStr := `{"Name":"liyi","Age":18,"Hobby":["抽烟","喝酒"],"sex":true}`
    //将json数据转为字节数据
    jsonbytes := []byte(jsonStr)
    //创建一个结构体
    Man1 := new(Man)
    err := json.Unmarshal(jsonbytes,&Man1)
    if err != nil {
        fmt.Println("反序列化失败,err=",err)
    }
    fmt.Println(*Man1)
}
  
//将json数据转换为map切片
func maina6(){
    jsonStr := `[{"age":21,"hobby":["打炮"],"name":"liyi","sex":true},{"name":"linging"},{"age":18,"hobby":["学习"],"name":"yiyi","sex":true}]`
    jsonBytes := []byte(jsonStr)
    dataSlice := make([]map[string]interface{},0)
    err := json.Unmarshal(jsonBytes,&dataSlice)
    if err != nil {
        fmt.Println("反序列化失败,err=",err)
    }
    fmt.Println(dataSlice)
}
  
//将json数据转为结构体切片
func maina7() {
    type Man struct {
        Name  string
        Age   int
        Hobby []string
        Sex   bool
    }
    jsonStr := `[{"age":21,"hobby":["打炮"],"name":"liyi","sex":true},{"name":"linging"},{"age":18,"hobby":["学习"],"name":"yiyi","sex":true}]`
    jsonBytes := []byte(jsonStr)
    Mans := make([]Man, 0)
    err := json.Unmarshal(jsonBytes, &Mans)
    if err != nil {
        fmt.Println("反序列化失败,err=", err)
    }
    fmt.Println(Mans)
}

  

Json编码与解码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
//编码:go数据--》json文件
//解码:json文件--》go数据
//使用json包编码
//注意:解码json数据,需要对应的数据类型的数据来接收!!!<br>
//将map类型数据编码为json文件
func mainb0() {
    //go数据:map类型
    dataMap1 := make(map[string]interface{})
    dataMap1["name"] = "liyi"
    dataMap1["age"] = 20
    dataMap1["hobby"] = []string{"唱歌", "跳舞"}
    dataMap1["sex"] = true
    //打开文件
    dstFile, _ := os.OpenFile("C:/test/test1.json", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    defer dstFile.Close()
    //创建编码器
    encoder := json.NewEncoder(dstFile)
    //编码
    err := encoder.Encode(dataMap1)
    if err != nil {
        fmt.Println("编码失败,err=", err)
        return
    }
    fmt.Println("编码成功")
  
}
  
//将结构体切片编码转为json文件
func mainb1(){
    type Man struct {
        Name  string
        Age   int
        Hobby []string
        Sex   bool
    }
    person1 := Man{"liyi",20,[]string{"唱歌","跳舞"},true}
    person2 := Man{"yiyi",20,[]string{"唱歌","跳舞"},true}
    person3 := Man{"meng",20,[]string{"唱歌","跳舞"},true}
    people := make([]Man,0)
    people = append(people,person1,person2,person3)
  
    dstFile,_ := os.OpenFile("C:/test/test1.json",os.O_CREATE | os.O_WRONLY | os.O_APPEND,0666)
    defer dstFile.Close()
    encoder := json.NewEncoder(dstFile)
    err := encoder.Encode(people)
    if err != nil {
        fmt.Println("编码失败,err=", err)
        return
    }
    fmt.Println("编码成功")
}
  
//解码json文件为map
func mainc1(){
    //打开json文件
    srcFile,_ := os.Open("C:/test/test1.json")
    defer srcFile.Close()
    //创建接收数据的map类型数据
    datamap := make(map[string]interface{})
    //创建解码器
    decoder := json.NewDecoder(srcFile)
    //解码
    err := decoder.Decode(&datamap)
    if err != nil{
        fmt.Println("解码失败,err=",err)
        return
    }
    fmt.Println("解码成功",datamap)
}
//解码json文件为结构体
func mainc2(){
    type Man struct {
        Name  string
        Age   int
        Hobby []string
        Sex   bool
    }
    //打开json文件
    srcFile,_ := os.Open("C:/test/test1.json")
    defer srcFile.Close()
  
    //创建接收数据的结构体数据
    datastruct := make([]Man,0)
  
    decoder := json.NewDecoder(srcFile)
    //解码
    err := decoder.Decode(&datastruct)
    if err != nil{
        fmt.Println("解码失败,err=",err)
        return
    }
    fmt.Println("解码成功",datastruct)
  
}

  

posted @   -零  阅读(2587)  评论(0编辑  收藏  举报
编辑推荐:
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列:向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行:
· TypeScript + Deepseek 打造卜卦网站:技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配,妙~啊~
· .NET Core 中如何实现缓存的预热?
历史上的今天:
2019-02-19 Django之模板基础
2019-02-19 Django之视图函数总结
点击右上角即可分享
微信分享提示