文章轉載自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串內切片的數據就沒辦法操作了。