Golang JSON、MD5、XML

JSON编码 使用encoding/json包

　　func Marshal(v interface{}) ([]byte, error)

package main
import (
	"encoding/json"
	"fmt"
)
func main() {
	//对数值型编码
	i := 5
	data, err := json.Marshal(i)
	//判断编码是否成功
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) //5

	//bool值编码
	flag := true
	data, err = json.Marshal(flag)
	fmt.Println(string(data)) //true   //注意不会编码为1

	//字符串
	str := "demo test"
	data, err = json.Marshal(str)
	fmt.Println(string(data)) //"demo test"

	//对数组编码
	arr := [5]int{1, 2, 3, 4, 5}
	data, err = json.Marshal(arr)
	fmt.Println(string(data))  //[1,2,3,4,5]

	//对map映射编码
	m := map[string]string{
		"one": "hello",
		"two": "world",
	}
	data, err = json.Marshal(m)
	fmt.Println(string(data))  //{"one":"hello","two":"world"}
}

　　

对结构体进行json编码

　　对结构体进行编码的时候，要注意，只会对可见的属性字段进行编码，不会对不可见的属性进行编码。

　　也就是说，只有当结构体中的属性首字母是大写的，才会对这个属性进行编码，否则会忽略掉首字母小写的属性。

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name   string  
	Age    int
	gender string
}

func main() {
	p := Person{"Jane", 33, "female"}
	data, _ := json.Marshal(p)
	fmt.Println(string(data)) //{"Name":"Jane","Age":33}
	//注意，首字母小写的gender属性并没有被编码
}

 

结构体中使用标签

　　在对结构体进行json编码的时候，还可以指定属性编码时，属性的名称，即可以替换原始的属性名。

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name   string `json:"person_name"`
	Age    int
	gender string
}

func main() {
	p := Person{"Jane", 33, "female"}
	data, _ := json.Marshal(p)
	fmt.Println(string(data)) //{"person_name":"Jane","Age":33}
	//注意，首字母小写的gender属性并没有被编码
	//p中的Name已经被改成了person_name，在结构体`json:"field"`指定
	//如果未指定`json:"field"`，则会沿用原属性名
}

　　

JSON解码

　　func Unmarshal(data []byte, v interface{}) error　　

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name   string `json:"person_name"`
	Age    int
	gender string
}

func EncodeAndDecode(source interface{}) {
	data, err := json.Marshal(source)
	if err != nil {
		panic(err)
	}
	fmt.Println("编码后：", string(data))

	var dest interface{}
	json.Unmarshal(data, &dest)
	fmt.Println("解码后：", dest)
}
func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	EncodeAndDecode(arr)
	//编码后： [1,2,3,4,5]
	//解码后： [1 2 3 4 5]

	flag := true
	EncodeAndDecode(flag)
	//编码后： true
	//解码后： true

	p := Person{"jane", 40, "female"}
	EncodeAndDecode(p)
	//编码后： {"person_name":"jane","Age":40}
	//解码后： map[person_name:jane Age:40]
}

　　注意结构体编码后在解码，结果是一个map。

 

XML编码和解码 使用encoding/xml包

　　xml编码的声明：func Marshal(v interface{}) ([]byte, error)

　　xml解码的声明：

package main

import (
	"encoding/xml"
	"fmt"
)

func main() {
	var data []byte
	var err error

	//字符串型转换为XML
	s := "hello world"
	//func Marshal(v interface{}) ([]byte, error)
	data, err = xml.Marshal(s)
	fmt.Println(string(data), err) //<string>hello world</string> <nil>

	//XML转为字符串型
	//func Unmarshal(data []byte, v interface{}) error
	var ss string
	xml.Unmarshal(data, &ss) //注意传递的是指针（地址）
	fmt.Println(ss)          //hello world
	//或者
	sss := new(string)
	xml.Unmarshal(data, sss)
	fmt.Println(*sss) //hello world

	//整型转换为XML
	i := 15
	data, err = xml.Marshal(i)
	fmt.Println(string(data), err) //<int>15</int> <nil>
	
	//XML转为整型
	var ii int
	xml.Unmarshal(data, &ii)
	fmt.Println(ii) //15
	//或者
	iii := new(int)
	xml.Unmarshal(data, iii)
	fmt.Println(*iii) //15
}

　　　　

结构体与XML的格式转换

　　将结构体编码为xml：注意在编码时，只对结构体中可见的属性进行编码，不会对不可见的属性（首字母小写）编码之后。

package main

import (
	"encoding/xml"
	"fmt"
)

type Person struct {
	Name string
	age  int
	Addr string
}

func main() {
	var data []byte
	var err error

	p := Person{"张飞", 1000, "北京"}

	//普通编码
	//func Marshal(v interface{}) ([]byte, error)
	data, err = xml.Marshal(p)
	fmt.Println(string(data), err)
	//<Person><Name>张飞</Name><Addr>北京</Addr></Person> <nil>

	//有缩进的编码
	//func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
	data, err = xml.MarshalIndent(p, "", "  ")
	fmt.Println(string(data), err)
	/*
		<Person>
		  <Name>张飞</Name>
		  <Addr>北京</Addr>
		</Person> <nil>
	*/

	//有前缀的编码
	data, err = xml.MarshalIndent(p, "#", " ")
	fmt.Println(string(data), err)
	/*
		#<Person>
		# <Name>张飞</Name>
		# <Addr>北京</Addr>
		#</Person> <nil>
	*/
}

　　

MD5加密

package main

import (
	"crypto/md5"
	"fmt"
)

func main() {
	Md5Instance := md5.New()
	//Md5Instance.Write([]byte("hello"))
	res := Md5Instance.Sum([]byte(""))
	fmt.Println(string(res)) //]A@*�K*v�q��Œ
	fmt.Printf("%x", res)    //5d41402abc4b2a76b9719d911017c592
}

　　md5加密之后，可以使用%x以16进制格式打印结果。