go语言的json

简介

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]
	}

}