Go的json解析:Marshal与Unmarshal
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
|
package main
import (
"encoding/json"
"fmt"
) type Stu struct {
Name string `json: "name" `
Age int
HIgh bool
sex string
Class *Class `json: "class" `
} type Class struct {
Name string
Grade int
} func main() {
//实例化一个数据结构,用于生成json字符串
stu := Stu{
Name: "张三" ,
Age: 18,
HIgh: true,
sex: "男" ,
}
//指针变量
cla := new(Class) //这个new方法,就相当于 cla := &Class{},是一个取地址的操作。
cla.Name = "1班"
cla.Grade = 3
stu.Class = cla
//Marshal失败时err!=nil
jsonStu, err := json.Marshal(stu)
if err != nil {
fmt.Println( "生成json字符串错误" )
}
//jsonStu是[]byte类型,转化成string类型便于查看
fmt.Println(string(jsonStu))
} //打印效果: { "name" : "张三" , "Age" :18, "HIgh" :true, "class" :{ "Name" : "1班" , "Grade" :3}}
从结果中可以看出 只要是可导出成员(变量首字母大写),都可以转成json。因成员变量sex是不可导出的,故无法转成json。 如果变量打上了json标签,如Name旁边的 `json: "name" ` ,那么转化成的json key就用该标签“name”,否则取变量名作为key,如“Age”,“HIgh”。
bool类型也是可以直接转换为json的value值。Channel, complex 以及函数不能被编码json字符串。当然,循环的数据结构也不行,它会导致marshal陷入死循环。 指针变量,编码时自动转换为它所指向的值,如cla变量。 (当然,不传指针,Stu struct 的成员Class如果换成Class struct 类型,效果也是一模一样的。只不过指针更快,且能节省内存空间。)
最后,强调一句:json编码成字符串后就是纯粹的字符串了。 |
上面的成员变量都是已知的类型,只能接收指定的类型,比如string类型的Name只能赋值string类型的数据。
但有时为了通用性,或使代码简洁,我们希望有一种类型可以接受各种类型的数据,并进行json编码。这就用到了interface{}类型。
前言:
interface{}类型其实是个空接口,即没有方法的接口。go的每一种类型都实现了该接口。因此,任何其他类型的数据都可以赋值给interface{}类型。
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
|
package main
type Stu struct {
Name interface {} `json: "name" `
Age interface {}
HIgh interface {}
sex interface {}
Class interface {} `json: "class" `
} type Class struct {
Name string
Grade int
} func main() {
//实例化一个数据结构,用于生成json字符串
stu := Stu{
Name: "张三" ,
Age: 18,
HIgh: true,
sex: "男" ,
}
//指针变量
cla := new(Class)
cla.Name = "1班"
cla.Grade = 3
stu.Class = cla
//Marshal失败时err!=nil
jsonStu, err := json.Marshal(stu)
if err != nil {
fmt.Println( "生成json字符串错误" )
}
//jsonStu是[]byte类型,转化成string类型便于查看
fmt.Println(string(jsonStu))
} //打印效果 //{"name":"张三","Age":18,"HIgh":true,"class":{"Name":"1班","Grade":3}} //从结果中可以看出,无论是string,int,bool,还是指针类型等,都可赋值给interface{}类型,且正常编码,效果与前面的例子一样。 |
补充:
在实际项目中,编码成json串的数据结构,往往是切片类型。如下定义了一个[]StuRead类型的切片
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
|
package main
import (
"encoding/json"
"fmt"
) func main() {
type StuRead struct {
Name interface {} `json: "name" `
Age interface {}
HIgh interface {}
sex interface {}
Class interface {} `json: "class" `
Test interface {}
}
//方式1:只声明,不分配内存
var stus1 []*StuRead
//方式2:分配初始值为0的内存
stus2 := make([]*StuRead,0)
//错误示范
//new()只能实例化一个struct对象,而[]StuRead是切片,不是对象
stus := new([]StuRead)
stu1 := &StuRead{ "asd1" ,1,1,1,1,1}
stu2 := &StuRead{ "asd2" ,2,2,2,2,2}
//由方式1和2创建的切片,都能成功追加数据
//方式2最好分配0长度,append时会自动增长。反之指定初始长度,长度不够时不会自动增长,导致数据丢失
stus1 = append(stus1,stu1) //因为上面stus1是切片类型的结构体指针类型,所以append的类型也必须是取的地址。
stus2 = append(stus2,stu2) //因为上面stus2是切片类型的结构体指针类型,所以append的类型也必须是取的地址。
//成功编码
json1,_ := json.Marshal(stus1)
json2,_ := json.Marshal(stus2)
fmt.Println(string(json1))
fmt.Println(string(json2))
} //打印效果 [{ "name" : "asd1" , "Age" :1, "HIgh" :1, "class" :1, "Test" :1}]
[{ "name" : "asd2" , "Age" :2, "HIgh" :2, "class" :2, "Test" :2}]
|
解码时定义对应的切片接受即可
Json Unmarshal:将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
|
type StuRead struct {
Name interface {} `json: "name" `
Age interface {}
HIgh interface {}
sex interface {}
Class interface {} `json: "class" `
Test interface {}
} type Class struct {
Name string
Grade int
} func main() {
//json字符中的"引号,需用\进行转义,否则编译出错
//json字符串沿用上面的结果,但对key进行了大小的修改,并添加了sex数据
data:= "{\"name\":\"张三\",\"Age\":18,\"high\":true,\"sex\":\"男\",\"CLASS\":{\"naME\":\"1班\",\"GradE\":3}}"
str:=[]byte(data)
//1.Unmarshal的第一个参数是json字符串,第二个参数是接受json解析的数据结构。
//第二个参数必须是指针,否则无法接收解析的数据,如stu仍为空对象StuRead{}
//2.可以直接stu:=new(StuRead),此时的stu自身就是指针
stu:=StuRead{}
err:=json.Unmarshal(str,&stu)
//解析失败会报错,如json字符串格式不对,缺"号,缺}等。
if err!=nil{
fmt.Println(err)
}
fmt.Println(stu)
} //打印效果 {张三 18 true <nil> map [naME:1班 GradE:3] <nil>}
|
总结:
json字符串解析时,需要一个“接收体”(也就是Unmarshal的第二个参数)接受解析后的数据,且Unmarshal时接收体必须传递指针。否则解析虽不报错,但数据无法赋值到接受体中。如这里用的是StuRead{}接收,就无法接收数据。
解析时,接收体可自行定义。json串中的key自动在接收体中寻找匹配的项进行赋值。匹配规则是:
-
先查找与key一样的json标签,找到则赋值给该标签对应的变量(如Name)。
没有json标签的,就从上往下依次查找变量名与key一样的变量,如Age。或者变量名忽略大小写后与key一样的变 量。如HIgh,Class。第一个匹配的就赋值,后面就算有匹配的也忽略。
(前提是该变量必需是可导出的,即首字母大写)。
不可导出的变量无法被解析(如sex变量,虽然json串中有key为sex的k-v,解析后其值仍为nil,即空值)
-
当接收体中存在json串中匹配不了的项时,解析会自动忽略该项,该项仍保留原值。如变量Test,保留空值nil。
-
你一定会发现,变量Class貌似没有解析为我们期待样子。因为此时的Class是个interface{}类型的变量,而json串中key为CLASS的value是个复合结构,不是可以直接解析的简单类型数据(如“张三”,18,true等)。所以解析时,由于没有指定变量Class的具体类型,json自动将value为复合结构的数据解析为map[string]interface{}类型的项。也就是说,此时的struct Class对象与StuRead中的Class变量没有半毛钱关系,故与这次的json解析没有半毛钱关系
让我们看一下这几个interface{}变量解析后的类型:
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
|
func main() {
//与前边json解析的代码一致
...
fmt.Println(stu) //打印json解析前变量类型
err:=json.Unmarshal(str,&stu)
fmt.Println( "--------------json 解析后-----------" )
...
fmt.Println(stu) //打印json解析后变量类型
} //利用反射,打印变量类型 func printType(stu *StuRead){
nameType:=reflect.TypeOf(stu.Name)
ageType:=reflect.TypeOf(stu.Age)
highType:=reflect.TypeOf(stu.HIgh)
sexType:=reflect.TypeOf(stu.sex)
classType:=reflect.TypeOf(stu.Class)
testType:=reflect.TypeOf(stu.Test)
fmt.Println( "nameType:" ,nameType)
fmt.Println( "ageType:" ,ageType)
fmt.Println( "highType:" ,highType)
fmt.Println( "sexType:" ,sexType)
fmt.Println( "classType:" ,classType)
fmt.Println( "testType:" ,testType)
} //结果 nameType: <nil> ageType: <nil> highType: <nil> sexType: <nil> classType: <nil> testType: <nil> --------------json 解析后----------- nameType: string ageType: float64 highType: bool sexType: <nil> classType: map [string] interface {}
testType: <nil> |
从结果中可见
-
interface{}类型变量在json解析前,打印出的类型都为nil,就是没有具体类型,这是空接口(interface{}类型)的特点。
-
json解析后,json串中value,只要是”简单数据”,都会按照默认的类型赋值,如”张三”被赋值成string类型到Name变量中,数字18对应float64,true对应bool类型。
1
2
|
“简单数据”:是指不能再进行二次json解析的数据,如”name”:”张三”只能进行一次json解析。 “复合数据”:类似”CLASS\”:{\”naME\”:\”1班\”,\”GradE\”:3}这样的数据,是可进行二次甚至多次json解析的,因为它的value也是个可被解析的独立json。即第一次解析key为CLASS的value,第二次解析value中的key为naME和GradE的value |
- 对于”复合数据”,如果接收体中配的项被声明为interface{}类型,go都会默认解析成map[string]interface{}类型。如果我们想直接解析到struct Class对象中,可以将接受体对应的项定义为该struct类型。如下所示:
1
2
3
4
5
6
7
|
type StuRead struct {
... //普通struct类型 Class Class `json: "class" `
//指针类型 Class *Class `json: "class" `
} |
1
|
// 打印效果 |
Class类型:{张三 18 true <nil> {1班 3} <nil>}
*Class类型:{张三 18 true <nil> 0xc42008a0c0 <nil>}