go 结构体转化为string_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串内切片的数据就没办法操作了。