一、Json和struct转换

1、json转化为struct结构体

json里面的key和struct里面的key要一致，struct中的key的首字母必须大写，而json中大小写都可以。如果json中使用的是小写，如何与struct中的保持一致呢？这里就可以使用tag在结构体定义的最后，加上和json中一样的tag标签即可。

 1package main
 2import (
 3    "encoding/json"
 4    "fmt"
 5)
 6type People struct {
 7    Name string `json:"name_title"`
 8    Age  int    `json:"age_size"`
 9}
10func main() {
11    jsonStr := `{
12            "name_title": "yang",
13            "age_size":30
14        }`
15    p := People{}
16    err := json.Unmarshal([]byte(jsonStr), &p)
17    if err != nil {
18        panic(err)
19    }
20    fmt.Println(p)
21    fmt.Println(p.Age)
22}

该示例中，输出结果如下：

1{yang 30}
230

上面的示例需要特别注意，yang后面的逗号不能少，少了打印p的值会变成{ 0} 。你可以试下看。

2、struct转json

在结构体中引入tag标签，这样匹配的时候json串对应的字段名需要与tag标签中定义的字段名匹配，当然tag中定义的名称不需要首字母大写，且对应的json串中字段名仍然大小写不敏感。此时，结构体中对应的字段名可以不用和匹配的一致，但是首字母必须大写，只有大写才是可对外提供访问的。

 1package main
 2import (
 3    "encoding/json"
 4    "fmt"
 5)
 6type People struct {
 7    Name string `json:"name_title"`
 8    Age  int    `json:"age_size"`
 9}
10func main() {
11    p := People{
12        Name: "yang",
13        Age:  18,
14    }
15    jsonBytes, err := json.Marshal(p)
16    if err != nil {
17        fmt.Println(err)
18    }
19    fmt.Println(string(jsonBytes))
20}

上面示例的输出结果为：

1{"name_title":"yang","age_size":18}

二、json和map转换

map 是一种无序的键值对的集合。map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

1、json转map

 1package main
 2import (
 3    "encoding/json"
 4    "fmt"
 5)
 6func main() {
 7    jsonStr := `
 8        {
 9            "name": "yang",
10            "age": 18
11        }
12        `
13    var mapResult map[string]interface{}
14    err := json.Unmarshal([]byte(jsonStr), &mapResult)
15    if err != nil {
16        fmt.Println("JsonToMapDemo err: ", err)
17    }
18    fmt.Println(mapResult)
19}

运行如果为：map[age:18 name:yang] 。上面的示例中，可以使用fmt.Println(mapResult[”name”]) 取出其中某个健值对应的值。

2、map转json

 1package main
 2import (
 3    "encoding/json"
 4    "fmt"
 5)
 6func main() {
 7    mapInstances := []map[string]interface{}{}
 8    instance_1 := map[string]interface{}{"name": "John", "age": 10}
 9    instance_2 := map[string]interface{}{"name": "Alex", "age": 12}
10    mapInstances = append(mapInstances, instance_1, instance_2)
11    jsonStr, err := json.Marshal(mapInstances)
12    if err != nil {
13        fmt.Println("MapToJsonDemo err: ", err)
14    }
15    fmt.Println(string(jsonStr))
16}

执行后，输出结果为：[{“age”:10,”name”:”John”},{“age”:12,”name”:”Alex”}] 。上面的示例中，也可以测试下传入一个instance进去，这样输出的就只有一个花括号json格式的数据。

三、map和struct互转

1、map转struct

这里使用了一个第三方库 go get github.com/goinggo/mapstructure，代码如下：

 1package main
 2import (
 3    "fmt"
 4    "github.com/goinggo/mapstructure"
 5)
 6type People struct {
 7    Name string `json:"name_title"`
 8    Age  int    `json:"age_size"`
 9}
10func main() {
11    mapInstance := make(map[string]interface{})
12    mapInstance["Name"] = "jqw"
13    mapInstance["Age"] = 18
14    var people People
15    err := mapstructure.Decode(mapInstance, &people)
16    if err != nil {
17        fmt.Println(err)
18    }
19    fmt.Println(people)
20}

输出结果：{jqw 18} 。

2、struct转map

 1package main
 2import (
 3    "fmt"
 4    "reflect"
 5)
 6type Student struct {
 7    ID   int    `json:"id"`
 8    Name string `json:"name_title"`
 9    Age  int    `json:"age_size"`
10}
11func StructToMapDemo(obj interface{}) map[string]interface{} {
12    obj1 := reflect.TypeOf(obj)
13    obj2 := reflect.ValueOf(obj)
14    var data = make(map[string]interface{})
15    for i := 0; i