在日常项目中，使用Json格式进行数据封装是比较常见的操作，看一下golang怎么实现。
1、json序列化
将json字符串转为go语言结构体对象。
|
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
|
package main import ( "encoding/json" "errors" "fmt") var parseJsonError = errors.New("json parse error")var toJsonError = errors.New("to json error") type CustomJson struct { Name string Age int} //序列化为jsonfunc toJson(c *CustomJson) (string, error) { fmt.Printf("原始结构体: %v\n", c) if jsonStr, err := json.Marshal(c); err != nil { fmt.Println("Error =", err) return "", parseJsonError } else { return string(jsonStr), nil } } func main() { w := CustomJson{Name: "李四", Age: 30} result, _ := toJson(&w) fmt.Println(result)} |
执行结果
原始结构体: &{李四 30}
{"Name":"李四","Age":30}
注意
结构体的字段首字母要大写。如果json字符串首字母都是小写怎么办？后面会说tag的使用。
2、Json反序列化为结构体对象
将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
|
package main import ( "encoding/json" "errors" "fmt") var parseJsonError = errors.New("json parse error")var toJsonError = errors.New("to json error") type CustomJson struct { Name string Age int} //反序列化为结构体对象func parseJson(a string) (CustomJson, error) { fmt.Printf("原始字符串: %s\n", a) var c CustomJson if err := json.Unmarshal([]byte(a), &c); err != nil { fmt.Println("Error =", err) return c, parseJsonError } return c, nil} func main() { j := `{"Name": "张三", "Age": 19}` if p, e := parseJson(j); e == nil { fmt.Printf("转换对象为: %v\n", p) }} |
执行结果
原始字符串: {"Name": "张三", "Age": 19}
转换对象为: {张三 19}
3、Json反序列化为map类型
将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
|
package main import ( "encoding/json" "errors" "fmt") var parseJsonError = errors.New("json parse error")var toJsonError = errors.New("to json error") type CustomJson struct { Name string Age int} //反序列化为mapfunc parseMap(a string) (map[string]interface{}, error) { fmt.Printf("原始字符串: %s\n", a) var m map[string]interface{} if err := json.Unmarshal([]byte(a), &m); err != nil { fmt.Println("Error =", err) return m, parseJsonError } for k, v := range m { fmt.Printf("k=%s,v类型为%T,v=%v\n", k, v, v) } return m, nil} func main() { j := `{"Name": "张三", "Age": 19}` if m, e := parseMap(j); e == nil { fmt.Printf("转换map为: %v\n", m) }} |
执行结果
原始字符串: {"Name": "张三", "Age": 19}
k=Name,v类型为string,v=张三
k=Age,v类型为float64,v=19
转换map为: map[Age:19 Name:张三]
注意
虽然是int类型的，但是反序列化的时候如果不做转换，会默认为float64。
4、Tag的使用
如果得到的json字符串每个key的首字母都是小写的，怎么转换为go的结构体对象呢？可以使用tag方式。
样例代码如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package main import ( "encoding/json" "fmt") type TestJson struct { Name string `json:"name"` Age int `json:"age"`} func main() { j := `{"name": "张三", "age": 19}` var c TestJson if err := json.Unmarshal([]byte(j), &c); err != nil { fmt.Println("Error =", err) } fmt.Println(">>>>", c)} |
执行结果
>>>> {张三 19}
注意
将原字符串的key作为tag打给结构体的字段，就可以实现字段转换了。
以上就是Go语言实现JSON解析的方法详解的详细内容，更多关于Go语言 JSON解析的资料请关注服务器之家其它相关文章！
原文链接：https://blog.csdn.net/zhiweihongyan1/article/details/124500362
