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

Go语言中使用json包中的 Marshal() 函数将数据结构转成json字符串，源代码：

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：

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：

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转结构体：

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：

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