go语言怎么判断一个结构体为空 go语言结构体和复杂json

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，易于别人阅读和编写，同时也易于机器解析和生成。(key-value)

数据格式说明

在JS语言中，一切都是对象因此任何数据类型都可以通过JSON来表示，例如字符串，数字，数组等。在go中还可以有map和结构体

JSON是用键值对的形式保存数据: {key:value}

{
  "name":"tom",
  "age": 18,
  "Addr":["浙江","杭州"]
}

json序列化

go中数组,结构体,map,切片。进行序列化(你可以认为序列化就是将不一致的数据转换成json数据)

结构体序列化

encoding/json

package main

import (
	"fmt"
	"encoding/json"
)

//定义一个结构体
type User struct{
	Uid int
	Name string
	Sex string
	Sal float64
	TeChang string
}

func testStruct() {
	//结构体初始化
	admin := User{
		Uid: 0,
		Name: "admin",
		Sex: "保密",
		Sal: 0,
		TeChang: "无",
	}

	//将admin序列化
	data,err := json.Marshal(&admin)
	if err != nil{
		fmt.Printf("序列化失败,err=%v\n",err)
	}
	//输出序列化后的结果
	fmt.Printf("admin序列化后的结果=%v\n",data)
}

func main(){
	testStruct()
}

查看结果fmt.Printf("admin序列化后的结果=%v\n",string(data))

序列化struct时tag使用

看到这个k值是大写的，如果浏览器希望是小写的
格式json:"名字"这个用的是反射机制

type User struct{
	Uid int `json:"uid"`
	Name string `json:"name"`
	Sex string `json:"sex"`
	Sal float64 `json:"sal"`
	TeChang string `json:"techang"`
}

map序列化

package main

import (
	"fmt"
	"encoding/json"
)

//将map进行序列化
func testMap(){
	//定义一个map
	var a map[string]interface{}
	//使用map,需要make
	a = make(map[string]interface{})
	a["name"] = "admin"
	a["age"] = 18
	a["addr"] = "四川"

	//将map序列化
	data,err := json.Marshal(a)
	if err != nil{
		fmt.Printf("序列化失败,err=%v\n",err)
	}
	//输出序列化后的结果
	fmt.Printf("admin序列化后的结果=%v\n",string(data))
}

func main(){
	testMap()
}

切片序列化

package main

import (
	"fmt"
	"encoding/json"
)

//对切片进行序列化
func testSlice(){
	//interface{}: 任意类型
	var slice []map[string]interface{}
	var m1 map[string]interface{}
	
	//使用map前需要先make
	m1 = make(map[string]interface{})
	m1["name"] = "jack"
	m1["age"] = 21
	m1["address"] = "北京"

	var m2 = make(map[string]interface{})
	m2["name"] = "tom"
	m2["age"] = 23
	m2["address"] = "四川成都"

	//写入切片
	slice = append(slice,m1) //slice中有一个map
	slice = append(slice,m2) //slice中有俩个map


	data,err := json.Marshal(slice)
	if err != nil{
		fmt.Printf("序列化失败,err=%v\n",err)
	}
	//输出序列化后的结果
	fmt.Printf("admin序列化后的结果=%v\n",string(data))
}



func main(){
	testSlice()
}

总结

data,err := json.Marshal(slice)
if err != nil{
  fmt.Printf("序列化失败,err=%v\n",err)
}
//输出序列化后的结果
fmt.Printf("admin序列化后的结果=%v\n",string(data))

json反序列化

json反序列化是指将json字符串反序列化成对应的数据类型(比如结构体、map、切片)

package main

import (
	"fmt"
	"encoding/json"
)

//需要有一个一样的结构体
type User struct{
	Name string
	Age int
	Addr string
}

//演示将json字符串，反序列化成struct
func UnmarshalForJSON(){
	//实际开发中，是通过网络传输获取的
	str := "{\"Name\":\"admin\",\"Age\":20,\"Addr\":\"上海\"}"

	//定义一个struct实例
	var user User
	//json.Unmarshal(对应字符串的byte切片,实例对象)
	err := json.Unmarshal([]byte(str),&user)
	if err != nil {
		fmt.Printf("反序列化失败,err=%v\n",err)
	}
	fmt.Printf("反序列化成功,user=%v\n",user)

}

func main(){
	UnmarshalForJSON()
}

案例: 读取json文件进行反序列化

json文件

{
    "Name":"admin",
    "Age": 20,
    "Addr":"上海",
    "Sex":"保密"
}

package main

import (
	"fmt"
	"io/ioutil"
	"encoding/json"
)

type User struct{
	Name string
    Age int
    Addr string
    Sex string
}

func ReadJSONFile(){
	data,err := ioutil.ReadFile("./test.json")
	if err != nil {
		fmt.Printf("read file error, err=%v\n",err)
	}
	str1 := string(data)
	// fmt.Printf("read file data=%v\n",string(str1))
	var user User
	err = json.Unmarshal([]byte(str1),&user)
	if err != nil {
		fmt.Printf("反序列化失败,err=%v\n",err)
	}
	fmt.Printf("反序列化成功,user=%v\n",user)
	
}


func main(){
	ReadJSONFile()
}

反序列化Map

package main

import (
	"fmt"
	"encoding/json"
)

//将json字符串反序列化成map
func UnmarshalMap(){
	str := "{\"addr\":\"温州\",\"age\":25,\"name\":\"admin\"}"
	//定义一个map
	var a map[string]interface{}

	//反序列化
	err := json.Unmarshal([]byte(str),&a)
	if err != nil {
		fmt.Printf("反序列化失败,err=%v\n",err)
	}
	fmt.Printf("反序列化成功,user=%v\n",a)
}

反序列化切片(slice)

package main

import (
	"fmt"
	"encoding/json"
)

//将json字符串，反序列化成切片
func UnmarshalForSlice(){
	str := "[{\"addr\":\"浙江\",\"name\":\"admin1\",\"age\":18},"+
	"{\"addr\":\"湖南\",\"name\":\"admin2\",\"age\":15}]"

	//定义一个切片
	var a []map[string]interface{}
	//反序列化，不需要make,因为make被封装到'Unmarshal'函数
	err := json.Unmarshal([]byte(str),&a)
	if err != nil {
		fmt.Printf("反序列化失败,err=%v\n",err)
	}
	fmt.Printf("反序列化成功,a=%v\n",a)
}




func main(){
	UnmarshalForSlice()
}

总结

1. 反序列化用到encoding/json的Unmarshal函数,Unmarshal([]byte(字符串),&数据类型)
2. 反序列化需要一个可以放入的元素，所以在反序列化时要知道转换的类型(结构体、map、slice等)