文章转载自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 mainimport ( "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
",string(result)) stu := getStudentInfo(13,"tom",[]string{"北京","上海","深圳"},true) fmt.Printf("type is %T
",stu) fmt.Printf("student = %+v
",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 mainimport ( "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 mainimport ( "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
",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 mainimport ( "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
",m) for key,value := range m{ //fmt.Printf("m[%s] = %+v
",key,value) //if key == "Address" { // fmt.Printf("%T
",value)//得出类型为接口类型 []interface {} 原本为 切片类型 //} //通过断言 推出数据的类型 switch data := value.(type) { case string: fmt.Printf("m[%s] = %s
",key,data) case float64: fmt.Printf("m[%s] = %f
",key,data) case bool: fmt.Printf("m[%s] = %v
",key,data) case []string: fmt.Println("是字符串切片类型") case []interface{}: fmt.Printf("是接口切片类型: %s =====> %v
",key,data) fmt.Println("======开始遍历切片======") for index,v := range data{ fmt.Printf("%s[%d] = %s
",key,index,v) } fmt.Println("======遍历切片结束======") } }} |
如果不通过断言去判断类型，如果需要遍历json串内切片的数据就没办法操作了。