Map 与 Json

个人觉得map与json很有意思呢，map与json可以实现互转

1、map是无序的，等同的数据，存储在map中、存储在json中，序列化json与序列化map是有不同结果的，举个栗子：

package MapByOrder

import (
	"encoding/base64"
	"fmt"
	"reflect"
	"encoding/json"
)

type Person struct{
	Name string `json:"name"`
	Phone string `json:"phone"`
	Number int64 `json:"number"`
}


func MapOrder(){
	
	var Persons []Person
	Persons = append(Persons,Person{
		Name:"lisa",
		Phone:"135000000000",
		Number:111,
	})
	Persons = append(Persons,Person{
		Name:"Michel",
		Phone:"137000000000",
		Number:222,
	})
	StrP_json, _:= json.Marshal(Persons)
	encodeString := base64.StdEncoding.EncodeToString(StrP_json)
	fmt.Printf("%v - %v\n encodeString: %v\n\n",reflect.TypeOf(Persons),Persons,string(encodeString))

	var MapPersons []interface{}
	var MapPerson1 = make(map[string]interface{})
	MapPerson1["name"] = "lisa"
	MapPerson1["phone"] = "135000000000"
	MapPerson1["number"] = 111

	var MapPerson2 = make(map[string]interface{})
	MapPerson2["name"] = "Michel"
	MapPerson2["phone"] = "137000000000"
	MapPerson2["number"] = 222

	MapPersons = append(MapPersons,MapPerson1)
	MapPersons = append(MapPersons,MapPerson2)

	MapP_json, _:= json.Marshal(MapPersons)
	encodeString2 := base64.StdEncoding.EncodeToString(MapP_json)
	fmt.Printf("%v - %v\n encodeString: %v\n\n",reflect.TypeOf(MapPersons),MapPersons,string(encodeString2))

	return 
}

然后输出结果是这样子的：

[]MapByOrder.Person - [{lisa 135000000000 111} {Michel 137000000000 222}]
 encodeString: W3sibmFtZSI6Imxpc2EiLCJwaG9uZSI6IjEzNTAwMDAwMDAwMCIsIm51bWJlciI6MTExfSx7Im5hbWUiOiJNaWNoZWwiLCJwaG9uZSI6IjEzNzAwMDAwMDAwMCIsIm51bWJlciI6MjIyfV0=

[]interface {} - [map[name:lisa phone:135000000000 number:111] map[name:Michel phone:137000000000 number:222]]
 encodeString: W3sibmFtZSI6Imxpc2EiLCJudW1iZXIiOjExMSwicGhvbmUiOiIxMzUwMDAwMDAwMDAifSx7Im5hbWUiOiJNaWNoZWwiLCJudW1iZXIiOjIyMiwicGhvbmUiOiIxMzcwMDAwMDAwMDAifV0=

尝试编译运行代码，可能每次的encodeString是不一样的

2、map转化成json，嵌套的数据也能正常解析，看下代码：

package  JsonParse

import (
	"fmt"
	"encoding/json"
)


type Parents struct{
	Father string `json:"father"`
	Mother string `json:"mother"`
}

type InnerJson struct{
	Name string `json:"name"`
	Age int `json:"age"`
	Relative Parents `json:"relative"` 
}

func JsonInner(){
	var value = make(map[string]interface{})
	value["name"] = "lisa"
	value["age"] = 16
	var subvalue = make(map[string]interface{})
	subvalue["father"] = "lisa-father"
	subvalue["mother"] = "lisa-mother"
	value["relative"] = subvalue

	var inner InnerJson
	bytesValue,_:=json.Marshal(value)
	json.Unmarshal(bytesValue,&inner)
	fmt.Printf("inner: %#v\n",inner)
}

然后，它的运行结果是这样子的：

inner: JsonParse.InnerJson{
	Name:"lisa", 
	Age:16, 
	Relative:JsonParse.Parents{
		Father:"lisa-father", 
		Mother:"lisa-mother"
		}
	}