20220828@结构体数据保存为JSON格式

JSON 格式是一种对象文本格式，是当前互联网最常用的信息交换格式之一。在Go语言中，可以使用 json.Marshal() 函数将结构体格式的数据格式化为 JSON 格式。

## 格式转换示例

想要使用 json.Marshal() 函数需要我们先引入 `encoding/json` 包，示例代码如下：
```go
package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string
        Level int
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",
        Age:  37,
        Skills: []Skill{
            {Name: "Roll and roll", Level: 1},
            {Name: "Flash your dog eye", Level: 2},
            {Name: "Time to have Lunch", Level: 3},
        },
    }
    result, err := json.Marshal(a)
    if err != nil {
        fmt.Println(err)
    }
    jsonStringData := string(result)
    fmt.Println(jsonStringData)
}
```
运行结果如下：
```
{
    "Name":"cow boy",
    "Age":37,
    "Skills":[
        {
            "Name":"Roll and roll",
            "Level":1
        },
        {
            "Name":"Flash your dog eye",
            "Level":2
        },
        {
            "Name":"Time to have Lunch",
            "Level":3
        }
    ]
}
```
通过运行结果可以看出我们成功的将结构体数据转换成了 JSON 格式。
提示：为了便于查看这里将输出结果做了格式化处理。

## json自定义名称输出

在转换 JSON 格式时，JSON 的各个字段名称默认使用结构体的名称，如果想要指定为其它的名称我们可以在声明结构体时添加一个`json:" "`标签，在" "中可以填入我们想要的内容，代码如下所示：
```go
package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string `json:"name"`
        Level int    `json:"level"`
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",
        Age:  37,
        Skills: []Skill{
            {Name: "Roll and roll", Level: 1},
            {Name: "Flash your dog eye", Level: 2},
            {Name: "Time to have Lunch", Level: 3},
        },
    }
    result, err := json.Marshal(a)
    if err != nil {
        fmt.Println(err)
    }
    jsonStringData := string(result)
    fmt.Println(jsonStringData)
}
```
运行结果如下：
```
{
    "Name":"cow boy",
    "Age":37,
    "Skills":[
        {
            "name":"Roll and roll",
            "level":1
        },
        {
            "name":"Flash your dog eye",
            "level":2
        },
        {
            "name":"Time to have Lunch",
            "level":3
        }
    ]
}
```
通过运行结果可以看出，我们成功将 Skill 结构体的 Name 和 Level 字段转换成了想要的内容。

## 过滤json空值

我们还可以在上面的标签的" "中加入 omitempty（使用逗号,与前面的内容分隔），来过滤掉转换的 JSON 格式中的空值，如下所示：
```go
package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string `json:"name,omitempty"`
        Level int    `json:"level"`
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",
        Age:  37,
        Skills: []Skill{
            {Name: "", Level: 1},
            {Name: "Flash your dog eye"},
            {Name: "Time to have Lunch", Level: 3},
        },
    }
    result, err := json.Marshal(a)
    if err != nil {
        fmt.Println(err)
    }
    jsonStringData := string(result)
    fmt.Println(jsonStringData)
}
```
运行结果如下：
```
{
    "Name":"cow boy",
    "Age":37,
    "Skills":[
        {
            "level":1
        },
        {
            "name":"Flash your dog eye",
            "level":0
        },
        {
            "name":"Time to have Lunch",
            "level":3
        }
    ]
}
```
通过对比 Skill 结构体的 Name 和 Level 字段可以看出，Name 字段的空值被忽略了，而 Level 字段则没有。

`json:" "` 标签的使用总结为以下几点：
- FieldName int `json:"-"`：表示该字段被本包忽略；
- FieldName int `json:"myName"`：表示该字段在 JSON 里使用“myName”作为键名；
- FieldName int `json:"myName,omitempty"`：表示该字段在 JSON 里使用“myName”作为键名，并且如果该字段为空时将其省略掉；
- FieldName int `json:",omitempty"`：该字段在json里的键名使用默认值，但如果该字段为空时会被省略掉，**注意omitempty 前面的逗号不能省略**。

## 完整代码示例

```go
package main

import (
	"encoding/json"
	"fmt"
)

func main() {

//声明一个子结构
	type skill struct {
		Name  string `json:"Development,omitempty"`
		Level int
	}

//声明一个父结构，包含子结构
	type Actor struct {
		Name  string
		Id    int64
		Skill []skill
	}

//对父结构进行实例化处理
	a := Actor{
		Name: "group",
		Id:   37187,
		Skill: []skill{
			{Name: "jj01", Level: 120},
			{Name: "jj02", Level: 121},
			{Name: "jj03", Level: 122},
			//当使用omitempty参数时，此处的Name
			//成员为空时，转换后的json中不会包含该值
			{Name: "", Level: 123},
		},
	}

//对实例化的结构a进行转json处理
	jsonValue, _ := json.Marshal(a)
	//将json格式转为字符串格式后再打印
	fmt.Println(string(jsonValue))
}

```

打印结果
```
[root@MacBook-Win L205Project]# gun  ./structConverJson.go 
{"Name":"group","Id":37187,"Skill":[{"Development":"jj01","Level":120},{"Development":"jj02","Level":
121},{"Development":"jj03","Level":122},{"Level":123}]}
```

学习结束地址：http://c.biancheng.net/view/vip_7327.html