Go 结构体和map等数据结构转json字符串

文章转载自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串内切片的数据就没办法操作了。

posted @ 2020-05-21 13:57  冰滴的眼泪  阅读(115)  评论(0编辑  收藏