文章转载自https://www.cnblogs.com/blog411032/p/10680355.html
Go语言中使用json包中的 Marshal() 函数将数据结构转成json字符串，源代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
func
Marshal(v
interface
{}) ([]byte, error) {
e := newEncodeState()
err := e.marshal(v, encOpts{escapeHTML: true})
if
err != nil {
return
nil, err
}
buf := append([]byte(nil), e.Bytes()...)
e.Reset()
encodeStatePool.Put(e)
return
buf, nil
}
|
该函数接收一个参数 接口形式的参数（如果参数定义成接口类型）则可以接收任何参数。有两个返回值：字符切片、错误。
结构体转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
|
package
main
import
(
"encoding/json"
"fmt"
)
//创建结构体
type
Student
struct
{
Id int
Name string
Address []string
IsWork bool
}
//封装返回结构体实例的方法
func
(s *Student) setStudentInfo(id int,name string,address []string, iswork bool) {
s.Address = address
s.Id = id
s.IsWork = iswork
s.Name = name
}
//封装返回结构体实例的方法 返回结构体的指针
func
getStudentInfo(id int,name string,address []string, iswork bool) *Student {
return
&Student{id,name,address,iswork}
}
func
main() {
var
s Student
//初始化结构体
s.setStudentInfo(12,
"jack"
,[]string{
"sh"
,
"bj"
},false)
//将结构体转成json
result , err := json.Marshal(s)
if
err != nil {
fmt.Println(
"error"
)
}
fmt.Printf(
"result = %+v\n"
,string(result))
stu := getStudentInfo(13,
"tom"
,[]string{
"北京"
,
"上海"
,
"深圳"
},true)
fmt.Printf(
"type is %T\n"
,stu)
fmt.Printf(
"student = %+v\n"
,stu)
//获取结构体的name属性 本来是指针，但是可以直接获取其属性，这是go语言的语法糖
fmt.Println(
"stu.Name = "
,stu.Name)
fmt.Println(
"(*stu).Name = "
,(*stu).Name)
result2,err2 := json.Marshal(stu)
if
err2 != nil {
fmt.Println(
"error"
)
}
fmt.Println(string(result2))
}
|
map转json：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package
main
import
(
"encoding/json"
"fmt"
)
func
main() {
m := make(
map
[string]
interface
{})
m[
"name"
] =
"jack"
m[
"address"
] = []string{
"北京"
,
"河南"
}
m[
"iswork"
] = false
m[
"age"
] = 18
result,err := json.Marshal(m)
if
err !=nil {
fmt.Println(
"error"
)
}
fmt.Println(string(result))
}
|
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
|
package
main
import
(
"encoding/json"
"fmt"
)
/**
json转结构体
*/
func
main() {
//json串 内包含 一个切片 一个 int类型的age 一个bool类型的iswork 和一个 字符串类型的name
jsonStr := `{
"Address"
:[
"北京"
,
"河南"
],
"Age"
:18,
"Iswork"
:false,
"Name"
:
"jack"
}`
var
p Person
json.Unmarshal([]byte(jsonStr),&p)
fmt.Printf(
" p = %+v\n"
,p)
}
//定义结构体
//结构体的名字首字母一定要大写，不然解析不出来
type
Person
struct
{
Name string
Age int
Iswork bool
Address []string
}
|
json转map：
|
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
|
package
main
import
(
"encoding/json"
"fmt"
)
func
main() {
//json串 内包含 一个切片 一个 int类型的age 一个bool类型的iswork 和一个 字符串类型的name
jsonStr := `{
"Address"
:[
"北京"
,
"河南"
],
"Age"
:18,
"Iswork"
:false,
"Name"
:
"jack"
}`
m := make(
map
[string]
interface
{})
json.Unmarshal([]byte(jsonStr),&m)
//fmt.Println(m)
//fmt.Printf("m = %+v\n",m)
for
key,value :=
range
m{
//fmt.Printf("m[%s] = %+v\n",key,value)
//if key == "Address" {
// fmt.Printf("%T\n",value)//得出类型为接口类型 []interface {} 原本为 切片类型
//}
//通过断言 推出数据的类型
switch
data := value.(
type
) {
case
string:
fmt.Printf(
"m[%s] = %s\n"
,key,data)
case
float64:
fmt.Printf(
"m[%s] = %f\n"
,key,data)
case
bool:
fmt.Printf(
"m[%s] = %v\n"
,key,data)
case
[]string:
fmt.Println(
"是字符串切片类型"
)
case
[]
interface
{}:
fmt.Printf(
"是接口切片类型: %s =====> %v\n"
,key,data)
fmt.Println(
"======开始遍历切片======"
)
for
index,v :=
range
data{
fmt.Printf(
"%s[%d] = %s\n"
,key,index,v)
}
fmt.Println(
"======遍历切片结束======"
)
}
}
}
|
如果不通过断言去判断类型，如果需要遍历json串内切片的数据就没办法操作了。