package main

import (

	"fmt"

	"encoding/json"

)

//定义一个结构体

type Monster struct {

	Name string `json:"monster_name"` //反射机制

	Age int `json:"monster_age"`

	Birthday string

	Sal float64

	Skill string

}

func testStruct() {

	//演示

	monster := Monster{

		Name :"牛魔王",

		Age : 500 ,

		Birthday : "2011-11-11",

		Sal : 8000.0,

		Skill : "牛魔拳",

	}

	fmt.Println(monster.Name) //牛魔王

	//将monster序列化

	data, err := json.Marshal(&monster) //元帅;马萨克;马歇尔;列集;调度

	if err != nil {

		fmt.Printf("序列号错误 err=%v\n", err)

	}

	//输出序列化后的结果

	fmt.Printf("monster序列化后=%v\n", string(data))

	//monster序列化后={"monster_name":"牛魔王","monster_age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}

}

func main() {

	testStruct()

}

package main

import (

	"fmt"

	"encoding/json"

)

//将map进行序列化

func testMap() {

	//定义一个map

	var a map[string]interface{} //可以把任何类型的变量给空接口

	//使用map,需要make

	a = make(map[string]interface{})

	a["name"] = "红孩儿"

	a["age"] = 30

	a["address"] = "洪崖洞"

	//将a这个map进行序列化

	//将monster 序列化

	data, err := json.Marshal(a)

	if err != nil {

		fmt.Printf("序列化错误 err=%v\n", err)

	}

	//输出序列化后的结果

	fmt.Printf("a map 序列化后=%v\n", string(data))

	//a map 序列化后={"address":"洪崖洞","age":30,"name":"红孩儿"}

}

func main() {

	testMap()

}

package main

import (

	"fmt"

	"encoding/json"

)

//演示对切片进行序列化, 我们这个切片 []map[string]interface{}

func testSlice() {

	var slice []map[string]interface{} //可以把任何类型的变量给空接口

	var m1 map[string]interface{}

	//使用map前，需要先make

	m1 = make(map[string]interface{})

	m1["name"] = "jack"

	m1["age"] = "7"

	m1["address"] = "北京"

	slice = append(slice, m1)

	var m2 map[string]interface{}

	//使用map前，需要先make

	m2 = make(map[string]interface{})

	m2["name"] = "tom"

	m2["age"] = "20"

	m2["address"] = [2]string{"墨西哥","夏威夷"}

	slice = append(slice, m2)

	//将切片进行序列化操作

	data, err := json.Marshal(slice)

	if err != nil {

		fmt.Printf("序列化错误 err=%v\n", err)

	}

	//输出序列化后的结果

	fmt.Printf("slice 序列化后=%v\n", string(data))

	//slice 序列化后=[{"address":"北京","age":"7","name":"jack"},{"address":["墨西哥","夏威夷"],"age":"20","name":"tom"}]

}

func main() {

	testSlice()//演示对切片的序列化

}

package main

import (

	"fmt"

	"encoding/json"

)

//对基本数据类型序列化，对基本数据类型进行序列化意义不大（只是转成字符串而已）

func testFloat64() {

	var num1 float64 = 2345.67

	//对num1进行序列化

	data, err := json.Marshal(num1)

	if err != nil {

		fmt.Printf("序列化错误 err=%v\n", err)

	}

	//输出序列化后的结果

	fmt.Printf("num1 序列化后=%v\n", string(data))

	//num1 序列化后=2345.67

}

func main() {

	testFloat64()//演示对基本数据类型的序列化

}

package main

import (

    "fmt"

    "encoding/json"

)

//定义一个结构体

type Monster struct {

    Name string

    Age int

    Birthday string //....

    Sal float64

    Skill string

}

//演示将json字符串，反序列化成struct

func unmarshalStruct() {

    //说明str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到

    //双引号里面还有双引号，需要转义

    str := "{\"Name\":\"牛魔王~~~\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"

    //定义一个Monster实例

    var monster Monster

    err := json.Unmarshal([]byte(str), &monster)

    if err != nil {

        fmt.Printf("unmarshal err=%v\n", err)

    }

    fmt.Printf("反序列化后 monster=%v monster.Name=%v \n", monster, monster.Name)

    //反序列化后 monster={牛魔王~~~ 500 2011-11-11 8000 牛魔拳} monster.Name=牛魔王~~~

}

//将map进行序列化

func testMap() string {

    //定义一个map

    var a map[string]interface{}

    //使用map,需要make

    a = make(map[string]interface{})

    a["name"] = "红孩儿~~~~~~"

    a["age"] = 30

    a["address"] = "洪崖洞"

    //将a这个map进行序列化

    //将monster 序列化

    data, err := json.Marshal(a)

    if err != nil {

        fmt.Printf("序列化错误 err=%v\n", err)

    }

    //输出序列化后的结果

    //fmt.Printf("a map 序列化后=%v\n", string(data))

    return string(data)

}

//演示将json字符串，反序列化成map

func unmarshalMap() {

    //str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"

    str := testMap()

    //定义一个map

    var a map[string]interface{}

    //反序列化

    //注意：反序列化map,不需要make,因为make操作被封装到 Unmarshal函数

    err := json.Unmarshal([]byte(str), &a)

    if err != nil {

        fmt.Printf("unmarshal err=%v\n", err)

    }

    fmt.Printf("反序列化后 a=%v\n", a)

    //反序列化后 a=map[address:洪崖洞 age:30 name:红孩儿~~~~~~]

}

//演示将json字符串，反序列化成切片

func unmarshalSlice() {

    str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," +

        "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"

    //定义一个slice

    var slice []map[string]interface{}

    //反序列化，不需要make,因为make操作被封装到 Unmarshal函数

    err := json.Unmarshal([]byte(str), &slice)

    if err != nil {

        fmt.Printf("unmarshal err=%v\n", err)

    }

    fmt.Printf("反序列化后 slice=%v\n", slice)

    //反序列化后 slice=[map[address:北京 age:7 name:jack] map[address:[墨西哥 夏威夷] age:20 name:tom]]

}

func main() {

    unmarshalStruct()

    unmarshalMap()

    unmarshalSlice()

}