struct和map转化为json串主要就是由于map无序，转化后的json串key是无序的

如果参数是接收一个参数，那么通过结构体和map转化都是可以的

代码示例：

package main

import (
	"encoding/json"
	"fmt"
)
type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
	Like []string `json:"like"` //不加`json:"like"`的话转化后的key为首字母大写的"Like"
}

func main(){
	fmt.Println("---------struct2json---------")
	struct2Json()
	fmt.Println("---------map2json------------")
	map2Json()

}

func struct2Json() {
	//转换从json的字段必须首字母大写

	stu := Person{"Yang", 31,[]string{"电影", "学习"}}

	//json_byte, err := json.Marshal(stu)
	json_byte, err := json.MarshalIndent(stu, "", " ") //看上去更加格式化
	//json_byte, err := json.Marshal(stu, )

	if err != nil {
		fmt.Println("json.Marshal error")
		return
	}
	fmt.Println(string(json_byte))

}


func map2Json() {
	person := make(map[string]interface{}, 6)
	person["name"] = "Yang"
	person["age"] = 31
	person["like"] = []string{"电影", "学习"}
	//json_byte, err := json.Marshal(stu)
	json_byte, err := json.MarshalIndent(person, "", " ") //进行格式处理
	if err != nil {
		fmt.Println("json.Marshal error")
		return
	}
	fmt.Println(string(json_byte))
}

输出结果：

---------struct2json---------
{
 "name": "Yang",
 "age": 31,
 "like": [
  "电影",
  "学习"
 ]
}
---------map2json------------
{
 "age": 31,
 "like": [
  "电影",
  "学习"
 ],
 "name": "Yang"
}

1.map和json的区别
相同点：都是key,value式的存储。
不同点是： json精确说键值也就是value支持String(存数值,数值存进,取String),map键值都存储象.

2.把map转化为json格式：

var jsonlist = [];
tojsonlist(mapData.Datas.helper)
function tojsonlist(objdata){
    var obj = {};
    var flag = false; 
    for(var attr in objdata){
        if(typeof objdata[attr] == 'object'){
            tojsonlist(objdata[attr])
        }else{
            flag = true;    
            obj[attr] = objdata[attr]; 
        }

    }
    if(flag){
        jsonlist.push(obj);
    }
}

假数据为：

var mapData = {
    "BillClassName": "BTripApply",
    "Datas": {
        "count": {
            "BTripApply": 1
        },
        "helper": {
            "BTripApply.BTripPerson": {
                "8b0c39c67d41427793b9665b155c5bf3": {
                    "Name": "测试用户",
                    "No": "test",
                    "OID": "8b0c39c67d41427793b9665b155c5bf3"
                }
            },
            "BTripApply.CreateCorp": {
                "1": {
                    "Name": "我是销售一部",
                    "No": "01",
                    "OID": "1"
                }
            },
            "BTripApply.CreateDept": {
                "38ac94a74bc44732863a713fa132b98e": {
                    "Name": "销售部",
                    "No": "001",
                    "OID": "38ac94a74bc44732863a713fa132b98e"
                }
            },
            "BTripApply.Creator": {
                "2": {
                    "Name": "超级管理员",
                    "No": "super",
                    "OID": "2"
                }
            }
        }
    }
}

目录

结构体生成json

json转成结构体

map生成json

json转化为map

结构体生成json

package main

import (
    "encoding/json"
    "fmt"
)

type IT struct {
    Company string `json:"-"` //此字段不会输出到屏幕
    //Company  string   `json:"company"`       这样打印输出别名首字母就会小写(二次编码)
    Subjects []string `json:"subjects"` //二次编码
    IsOk     bool     `json:",string"`
    Price    float64  `json:",string"`
}

func main() {
    //定义一个结构体变量，同时初始化
    s := IT{"itcast", []string{"Golang", "PHP", "Java", "C++"}, true, 666.666}

    //编码，根据内容生成json文本
    //buf, err := json.Marshal(s)
    //buf =  {"subjects":["Golang","PHP","Java","C++"],"IsOk":"true","Price":"666.666"}
    buf, err := json.MarshalIndent(s, "", "    ") //格式化编码
    if err != nil {
        fmt.Println("err = ", err)
        return
    }

    fmt.Println("buf = ", string(buf))
}

输出结果：

buf =  {
        "subjects": [   //首字母小写
               "Golang",
                "PHP",
                "Java",
                "C++"
        ],
       "IsOk": "true",   //string类型
       "Price": "666.666"
}

json转成结构体

package main

import (
    "encoding/json"
    "fmt"
)

type IT struct {
    Address   string   `json:"address"`
    Languages []string `json:"languages"` //二次编码
    Status    bool     `json:"isok"`
    Price     float64  `json:"price"`
}

func main() {

    jsonBuf := `
    {
    "address": "北京",
    "languages": [
        "Golang",
        "PHP",
        "Java",
        "Python"
    ],
    "status": true,
    "price": 666.666
}`

    var tmp IT                                   //定义一个结构体变量
    err := json.Unmarshal([]byte(jsonBuf), &tmp) //第二个参数要地址传递
    if err != nil {
        fmt.Println("err = ", err)
        return
    }
    //fmt.Println("tmp = ", tmp)
    fmt.Printf("tmp = %+v\n", tmp)

    type IT2 struct {
        Subjects []string `json:"languages"` //二次编码
    }

    var tmp2 IT2
    err = json.Unmarshal([]byte(jsonBuf), &tmp2) //第二个参数要地址传递
    if err != nil {
        fmt.Println("err = ", err)
        return
    }
    fmt.Printf("tmp2 = %+v\n", tmp2)

}

输出结果：

tmp = {Address:北京 Languages:[Golang PHP Java Python] Status:false Price:666.666}
tmp2 = {Subjects:[Golang PHP Java Python]}

map生成json

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    //创建一个map
    m := make(map[string]interface{}, 4) //因为类型多，可以用interface空接口
    m["address"] = "北京"
    m["languages"] = []string{"Golang", "PHP", "Java", "Python"}
    m["status"] = true
    m["price"] = 666.666

    //编码成json
    //result, err := json.Marshal(m)
    //result =  {"address":"北京","languages":["Golang","PHP","Java","Python"],"price":666.666,"status":true}
    result, err := json.MarshalIndent(m, "", "    ")
    if err != nil {
        fmt.Println("err = ", err)
        return
    }
    fmt.Println("result = ", string(result))
}

输出结果：

result =  {
        "address": "北京",
        "languages": [
                "Golang",
                "PHP",
                "Java",
                "Python"
        ],
        "price": 666.666,
        "status": true
}

json转化为map

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonBuf := `
    {
    "company": "itcast",
    "subjects": [
        "Go",
        "C++",
        "Python",
        "Test"
    ],
    "isok": true,
    "price": 666.666
}`

    //创建一个map
    m := make(map[string]interface{}, 4)

    err := json.Unmarshal([]byte(jsonBuf), &m) //第二个参数要地址传递
    if err != nil {
        fmt.Println("err = ", err)
        return
    }
    fmt.Printf("m = %+v\n", m)

    //    var str string
    //    str = string(m["company"]) //err， 无法转换
    //    fmt.Println("str = ", str)

    var str string

    //类型断言, 值，它是value类型
    for key, value := range m {
        //fmt.Printf("%v ============> %v\n", key, value)
        switch data := value.(type) {
        case string:
            str = data
            fmt.Printf("map[%s]的值类型为string, value = %s\n", key, str)
        case bool:
            fmt.Printf("map[%s]的值类型为bool, value = %v\n", key, data)
        case float64:
            fmt.Printf("map[%s]的值类型为float64, value = %f\n", key, data)
        case []string:
            fmt.Printf("map[%s]的值类型为[]string, value = %v\n", key, data)
        case []interface{}:
            fmt.Printf("map[%s]的值类型为[]interface, value = %v\n", key, data)
        }

    }

}

输出结果：

map[address]的值类型为string, value = 北京
map[Languages]的值类型为[]interface, value = [Golang PHP Java Python]
map[Status]的值类型为bool, value = true
map[price]的值类型为float64, value = 666.666000