有时会有这种需求，将一个json数据形如：
|
1
|
{"x":"golang", "y":"520.1314"}
|
中的y反序列化为浮点类型，如果这样写：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package main
import (
"encoding/json"
"fmt"
)
type JsonTest struct {
X string `json:"x"`
Y float64 `json:"y"`
}
func main() {
s := `{"x":"golang", "y":"520.1314"}`
var jt JsonTest
err := json.Unmarshal([]byte(s), &jt)
if err == nil {
fmt.Printf("%+v\n", jt)
} else {
fmt.Println(err)
fmt.Printf("%+v\n", jt)
}
}
|
会报错：
json: cannot unmarshal string into Go struct field JsonTest.y of type float64
将结构体JsonTest定义改为如下，即可解决战斗：
|
1
2
3
4
|
type JsonTest struct {
X string `json:"x"`
Y float64 `json:"y,string"`
}
|
这样写可以告诉golang的json解释器变量y是被编码成字符串的浮点数
补充：golang中struct、json、map互相转化
一、Json和struct互换
（1）Json转struct例子：
|
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
|
package main
import (
"fmt"
"encoding/json"
)
type People struct {
Name string `json:"name_title"`
Age int `json:"age_size"`
}
func JsonToStructDemo(){
jsonStr := `
{
"name_title": "jqw"
"age_size":12
}
`
var people People
json.Unmarshal([]byte(jsonStr), &people)
fmt.Println(people)
}
func main(){
JsonToStructDemo()
}
|
输出：
注意json里面的key和struct里面的key要一致，struct中的key的首字母必须大写，而json中大小写都可以。
（2）struct转json
在结构体中引入tag标签，这样匹配的时候json串对应的字段名需要与tag标签中定义的字段名匹配，当然tag中定义的名称不需要首字母大写，且对应的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
|
package main
import (
"fmt"
"encoding/json"
)
type People struct {
Name string `json:"name_title"`
Age int `json:"age_size"`
}
func StructToJsonDemo(){
p := People{
Name: "jqw",
Age: 18,
}
jsonBytes, err := json.Marshal(p)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(jsonBytes))
}
func main(){
StructToJsonDemo()
}
|
输出：
二、json和map互转
（1）json转map例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
func JsonToMapDemo(){
jsonStr := `
{
"name": "jqw",
"age": 18
}
`
var mapResult map[string]interface{}
err := json.Unmarshal([]byte(jsonStr), &mapResult)
if err != nil {
fmt.Println("JsonToMapDemo err: ", err)
}
fmt.Println(mapResult)
}
|
输出：
（2）map转Json例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
func MapToJsonDemo1(){
mapInstances := []map[string]interface{}{}
instance_1 := map[string]interface{}{"name": "John", "age": 10}
instance_2 := map[string]interface{}{"name": "Alex", "age": 12}
mapInstances = append(mapInstances, instance_1, instance_2)
jsonStr, err := json.Marshal(mapInstances)
if err != nil {
fmt.Println("MapToJsonDemo err: ", err)
}
fmt.Println(string(jsonStr))
}
|
输出：
例2：
|
1
2
3
4
|
func MapToJsonDemo2(){
b, _ := json.Marshal(map[string]int{"test":1, "try":2})
fmt.Println(string(b))
}
|
输出：
三、map和struct互转
（1）map转struct
需要安装一个第三方库
在命令行中运行： go get github.com/goinggo/mapstructure
例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
func MapToStructDemo(){
mapInstance := make(map[string]interface{})
mapInstance["Name"] = "jqw"
mapInstance["Age"] = 18
var people People
err := mapstructure.Decode(mapInstance, &people)
if err != nil {
fmt.Println(err)
}
fmt.Println(people)
}
|
输出
（2）struct转map例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
func StructToMapDemo(obj interface{}) map[string]interface{}{
obj1 := reflect.TypeOf(obj)
obj2 := reflect.ValueOf(obj)
var data = make(map[string]interface{})
for i := 0; i < obj1.NumField(); i++ {
data[obj1.Field(i).Name] = obj2.Field(i).Interface()
}
return data
}
func TestStructToMap(){
student := Student{10, "jqw", 18}
data := StructToMapDemo(student)
fmt.Println(data)
}
|
输出：
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：http://www.jianshu.com/p/9856478555c5