Golang Json 编解码

**Go语言中的JSON编解码**

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于阅读和书写。Go语言提供了一个强大的JSON编解码库，可以方便地将Go结构体转换为JSON字符串，并且可以从JSON字符串中反序列化为Go结构体。

**json包**

Go语言中的`encoding/json`包提供了JSON编解码的功能。这个包包含两个主要函数：`Encode()`和`Decode()`。

### Encode()

`Encode()`函数用于将Go结构体转换为JSON字符串。它接受一个参数，表示要序列化的结构体，然后返回一个字节流（即JSON字符串）。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
Email: "john@example.com",
}
	jsonStr, err := json.Marshal(p)
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(string(jsonStr))
}

在上面的例子中，我们定义了一个`Person`结构体，并将其序列化为JSON字符串。注意，`json:"name"`这样的注释是用于指定JSON中的键名的。

### Decode()

`Decode()`函数用于从JSON字符串反序列化为Go结构体。它接受两个参数：一个字节流（即JSON字符串）和一个指向要填充的结构体的指针。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	jsonStr := `{"name":"John","age":30,"email":"john@example.com"}`
	var p Person	err := json.Unmarshal([]byte(jsonStr), &p)
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(p.Name, p.Age, p.Email)
}

在上面的例子中，我们使用`json.Unmarshal()`函数将JSON字符串反序列化为一个`Person`结构体。

### Marshal()

`Marshal()`函数用于将Go结构体转换为JSON字节流。它接受一个参数，表示要序列化的结构体，然后返回一个字节流（即JSON字符串）。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
Email: "john@example.com",
}
	jsonStr, err := json.Marshal(p)
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(string(jsonStr))
}

在上面的例子中，我们使用`json.Marshal()`函数将一个`Person`结构体序列化为JSON字节流。

### Unmarshal()

`Unmarshal()`函数用于从JSON字节流反序列化为Go结构体。它接受两个参数：一个字节流（即JSON字符串）和一个指向要填充的结构体的指针。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	jsonStr := `{"name":"John","age":30,"email":"john@example.com"}`
	var p Person	err := json.Unmarshal([]byte(jsonStr), &p)
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(p.Name, p.Age, p.Email)
}

在上面的例子中，我们使用`json.Unmarshal()`函数将JSON字节流反序列化为一个`Person`结构体。

### MarshalIndent()

`MarshalIndent()`函数用于将Go结构体转换为JSON字节流，并且可以指定缩进的字符。它接受两个参数：表示要序列化的结构体和一个字符串，表示缩进的字符，然后返回一个字节流（即JSON字符串）。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
Email: "john@example.com",
}
	jsonStr, err := json.MarshalIndent(p, "", "t")
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(string(jsonStr))
}

在上面的例子中，我们使用`json.MarshalIndent()`函数将一个`Person`结构体序列化为JSON字节流，并且指定了缩进的字符。

### UnmarshalIndent()

`UnmarshalIndent()`函数用于从JSON字节流反序列化为Go结构体，并且可以指定缩进的字符。它接受三个参数：一个字节流（即JSON字符串）、一个指向要填充的结构体的指针和一个字符串，表示缩进的字符。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func main() {
	jsonStr := `{"name":"John","age":30,"email":"john@example.com"}`
	var p Person	err := json.UnmarshalIndent([]byte(jsonStr), &p, "t")
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(p.Name, p.Age, p.Email)
}

在上面的例子中，我们使用`json.UnmarshalIndent()`函数将JSON字节流反序列化为一个`Person`结构体，并且指定了缩进的字符。

### Marshaler`Marshaler`接口用于表示可以将Go结构体转换为JSON字节流的类型。它有一个方法：`MarshalJSON()`,返回一个字节流（即JSON字符串）。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func (p *Person) MarshalJSON() ([]byte, error) {
	return json.Marshal(p)
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
Email: "john@example.com",
}
	jsonStr, err := p.MarshalJSON()
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(string(jsonStr))
}

在上面的例子中，我们定义了一个`Person`结构体，并实现了`Marshaler`接口。然后我们使用`p.MarshalJSON()`函数将这个结构体序列化为JSON字节流。

### Unmarshaler`Unmarshaler`接口用于表示可以从JSON字节流反序列化为Go结构体的类型。它有一个方法：`UnmarshalJSON()`,接受一个字节流（即JSON字符串）和一个指向要填充的结构体的指针。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func (p *Person) UnmarshalJSON(b []byte) error {
	return json.Unmarshal(b, p)
}

func main() {
	jsonStr := `{"name":"John","age":30,"email":"john@example.com"}`
	var p Person	err := p.UnmarshalJSON([]byte(jsonStr))
	if err != nil {
	fmt.Println(err)
	return}
	fmt.Println(p.Name, p.Age, p.Email)
}

在上面的例子中，我们定义了一个`Person`结构体，并实现了`Unmarshaler`接口。然后我们使用`p.UnmarshalJSON()`函数将JSON字节流反序列化为这个结构体。

### Marshaler和Unmarshaler`Marshaler`和`Unmarshaler`接口可以同时被实现，表示一个类型既可以将Go结构体转换为JSON字节流，也可以从JSON字节流反序列化为Go结构体。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email"`
}

func (p *Person) MarshalJSON() ([]byte, error) {
	return json.Marshal(p)
}

func (p *Person) UnmarshalJSON(b []byte) error {
	return json.Unmarshal(b, p)
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
Email