How does Go handle JSON serialization and deserialization? Provide code examples.

In Go, working with JSON serialization and deserialization is straightforward and built-in functionality is provided by the standard library. Go provides a convenient way to convert Go data structures to JSON format (serialization) and vice versa (deserialization). This is particularly useful when exchanging data with external systems or APIs that communicate using JSON.

To serialize Go data structures to JSON, you can use the `encoding/json` package from the standard library. This package provides functions and types for encoding and decoding JSON data.

Here's an example of serializing a Go struct to JSON:

```
go`package main

import (
"encoding/json"
"fmt"
)

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

func main() {
person := Person{
Name: "John Doe",
Age: 30,
Email: "john.doe@example.com",
}

jsonData, err := json.Marshal(person)
if err != nil {
fmt.Println("Error:", err)
return
}

fmt.Println(string(jsonData))
}`
```
In the above example, we define a `Person` struct with three fields: `Name`, `Age`, and `Email`. The `json` struct tags specify the corresponding keys in the JSON output. The `Email` field has an `omitempty` directive, which means it will be omitted from the JSON output if it's empty.

The `json.Marshal()` function is used to serialize the `Person` struct to JSON format. If the serialization is successful, it returns a byte slice containing the JSON data.

To deserialize JSON data back into Go data structures, you can use the `json.Unmarshal()` function:

```
go`package main

import (
"encoding/json"
"fmt"
)

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

func main() {
jsonData := []byte(`{"name":"John Doe","age":30,"email":"john.doe@example.com"}`)

var person Person
err := json.Unmarshal(jsonData, &person)
if err != nil {
fmt.Println("Error:", err)
return
}

fmt.Println("Name:", person.Name)
fmt.Println("Age:", person.Age)
fmt.Println("Email:", person.Email)
}`
```
In the above example, we define a JSON string `jsonData` representing a `Person` object. The `json.Unmarshal()` function is used to deserialize the JSON data into the `person` variable of type `Person`. If the deserialization is successful, the `person` variable will contain the data from the JSON.

Go's JSON package uses reflection to map JSON fields to struct fields, based on the `json` struct tags. By utilizing this functionality, you can easily handle more complex JSON structures, nested objects, arrays, and custom data types.

Overall, Go provides a simple and efficient way to handle JSON serialization and deserialization with its built-in `encoding/json` package, making it convenient to work with JSON data in Go applications.