简介
json 中提供的处理 json 的标准包是 encoding/json,主要使用的是以下两个方法：
// 序列化
func Marshal(v interface{}) ([]byte, error)
// 反序列化
func Unmarshal(data []byte, v interface{}) error
1、编码json
可以把一个结构体编码为json，也可以把一个map编码为json
package main
import (
"encoding/json"
"fmt"
)
//编码json,使用json.Marshal（）函数可以对一组数据进行json格式的编码
//定义 一个结构体
type Test39Person struct {
//这里的属性必须是大写开头
Test1 string
Test2 string
}
//看下后面的打印就知道什么意思了，实现小写也可以了，这里也可以搞一个匿名变量，不会打印,用-
type Test39Person1 struct {
//这里的属性必须是大写开头
Test1 string `json:"-"`
Test2 string `json:"hob"`
}
func main() {
//1、通过结构体生成json
p := Test39Person{ Test1:"abc", Test2:"ate"}
p2 := Test39Person1{ Test1:"abc", Test2:"ate"}
fmt.Println(p)
//1、生成json文本
b,e := json.Marshal(p)
if e != nil {
fmt.Println(e)
}
fmt.Println(string(b))
//{"Test1":"abc","Test2":"ate"}
//2、生成格式化json
//prefix是前缀的意思，indent
c,e := json.MarshalIndent(p,"*"," ")
fmt.Println(string(c))
//{
// * "Test1": "abc",
// * "Test2": "ate"
// *}
c,e = json.MarshalIndent(p2,"*"," ")
fmt.Println(string(c))
//{
// * "hob": "ate"
// *}
//3、通过map生成json
//interface这个表示任意类型
nnp := make(map[string]interface{})
nnp["name"] = "ccc"
nnp["age"] = 12
nnp["hob"] = true
f,e := json.Marshal(nnp)
if e != nil {
fmt.Println(e)
}else {
fmt.Println(string(f))
//{"age":12,"hob":true,"name":"ccc"}
}
}
2、解码json
可以解码到结构体，也可以解码到接口
package main
import (
"encoding/json"
"fmt"
"reflect"
)
//解码json
type Test40Person struct {
//这里的属性必须是大写开头
Test1 string
Test2 string
}
func main() {
//准备一段json
b := []byte(`{"Test1":"abc","Test2":"ate"}`)
//把json解析到结构体
var t Test40Person
e := json.Unmarshal(b,&t)
if e != nil {
fmt.Println(e)
}
fmt.Println(t,reflect.TypeOf(t))
//{abc ate} main.Test40Person
//解析到接口，解析出来的数据是map
var i interface{}
err := json.Unmarshal(b,&i)
if err != nil {
fmt.Println(err)
}
fmt.Println(i,reflect.TypeOf(i))
//map[Test1:abc Test2:ate] map[string]interface {}
//调用interface的json，可以判断类型
m := i.(map[string]interface{})
for k,v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k,"是string类型",vv)
case int:
fmt.Println(k,"是int类型",vv)
default:
fmt.Println(k,"是其他类型",vv)
}
}
}
1、序列化为结构体为json，采用json.Marshal()方法
package main
import (
"encoding/json"
"fmt"
"reflect"
)
//定义一个结构体
type Test5Person struct {
Test1 string
Test2 byte
Test3 bool
Test4 int
}
func main() {
//将一个结构体序列化为json
t5_1 := Test5Person{Test1:"aaa",Test2:'b',Test3:false,Test4:12}
fmt.Println(t5_1)
//{aaa 98 false 12}
d,e := json.Marshal(t5_1)
if e != nil {
fmt.Println(e)
}else {
fmt.Println(string(d),reflect.TypeOf(d))
//{"Test1":"aaa","Test2":98,"Test3":false,"Test4":12} []uint8
}
}
2、序列化map为json，采用json.Marshal()方法
package main
import (
"encoding/json"
"fmt"
)
type Test6Map1 map [string] interface{}
func main() {
var t6_1 = Test6Map1{"test1":"test111","test2":"test222","test3":"test333"}
d,e := json.Marshal(t6_1)
if e != nil {
fmt.Println(e)
}else {
fmt.Println(string(d))
}
var t6_2 = make(map[int]interface{},10)
t6_2[1] = "11111111"
t6_2[2] = 22222222
t6_2[3] = 'b'
t6_2[4] = true
t6_2[5] = 3.14
t6_2[6] = false
d,e = json.Marshal(t6_2)
if e != nil {
fmt.Println(e)
}else {
fmt.Println(string(d))
}
//{"1":"11111111","2":22222222,"3":98,"4":true,"5":3.14,"6":false}
}
3、反序列化，采用json.Unmarshal(b,&i)方法
package main
import (
"encoding/json"
"fmt"
)
type Test7Person1 struct {
Name1 string
Name2 int
Name3 byte
Name4 bool
Name5 float32
//Name6 bool
}
func main() {
//反序列化到结构体，只会反序列化结构体中有的字段，如果json中有字段1，而在结构体中没有字段1，则反序列化就不会有字段1
var b = []byte(`{"Name1":"11111111","Name2":22,"Name3":98,"Name4":true,"Name5":3.14,"Name6":false}`)
//var b = []byte(`{"Name1":"test1","Name2":"test2","Name3":"test3"}`)
var t7 Test7Person1
e := json.Unmarshal(b,&t7)
if e != nil {
fmt.Println(e)
}else {
fmt.Println(t7)
//{11111111 22 98 true 3.14}
}
//反序列化到接口
var i interface{}
e1 := json.Unmarshal(b,&i)
if e1 != nil {
fmt.Println(e)
}else {
fmt.Println(i)
//map[Name1:11111111 Name2:22 Name3:98 Name4:true Name5:3.14 Name6:false]
}
}