likes
comments
collection
share

重学Go语言 | Go的JSON操作

作者站长头像
站长
· 阅读数 21

公众号：程序员读书，欢迎关注

当你想在项目中保存配置时，你会选择什么数据格式，你可能会说用yaml或是json，当你作为后端要把数据返回给前端时，你会选择什么数据格式，这次我想，一定是json了吧。

关于在Go语言如何操作JSON，在这篇文章我们来探究一下！

JSON

什么是JSON？JSON的全称是Javascript Object Notation，是一种数据结构化交互的标准协议，非常容易阅读与编写，可以作为配置文件保存应用的相关配置信息，也可以作为前后端接口数据的格式，比如后端返回给前端这样的JSON数据：

{
	"code":404,
	"msg":"Not Found"
}

JSON的数据类型

JSON只支持六种数据类型，分别是：

  • 数字(number)：有十进制和科学记数学两种表示方式。

  • 字符串(string)：使用双引号表示的Unicode字符序列。

  • 布尔(bool)：true或者false。

  • 对象(object)：使用花括号({})括起来的一个或多个键值对(key/value)，用逗号(,)隔开，最后一个键值对后面不能有逗号，键(key)必是双引号("")引起来的字符串，而值则可以是任意类型(如：布尔、数字、对象、数组、字符串)。

  • 数组(array)：使用中括号([])括起来的值的集合，这些值可是任意类型(布尔、数字、对象、数组、字符串)。

  • null:空值。

JSON类型与Go数据类型的对应关系：

  • Go的boolean对应JSON的bool类型
  • Go的整型与浮点型对应JSON的number类
  • Go的map和struct对应JSON的object，map的key必须是字符串
  • Go的切片与数组对应JSON的array
  • Go的chan与函数等复杂的类型不能作为JSON的值

JSON的基本操作

Go语言在encoding/json包中提供了JSON数据序列化与反序列化的操作，最简单直接就是调用Marshal把一个Go的数据序列化为一个JSON数据和调用Unmarshal对JSON数据反序列化。

Marshal

json包的Marshal()函数用于将数据编码为一个JSON文本，该函数的签名如下所示：

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

Marshal()函数可以接受任意值，并返回JSON化的字节数组与一个error类型：

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	m := map[string]int{"Go入门": 1, "Go Ation": 2, "Go从入门到精通": 3, "Go高级编程": 4}
	data, err := json.Marshal(m)
	if err != nil {
		panic(err)
	}
    //转换为string并输出
	fmt.Println(string(data)) 
}

上面示例程序的运行结果:

{"Go Ation":2,"Go从入门到精通":3,"Go入门":1,"Go高级编程":4}

MarshalIndent

上面调用Marshal函数序列化的数据输出了一行，如果数据太长，则不利于我们阅读，要想输出的JSON数据格式更友好一点，可以用MarshalIndent函数，该函数签名如下：

func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)

相比于Marshal函数，MarshalIndent函数可以接收一个prefix和indent，用于设置输出JSON每一行的前缀和首行缩进，下面是一个使用该函数的例子：

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	m := map[string]int{"Go入门": 1, "Go Ation": 2, "Go从入门到精通": 3, "Go高级编程": 4}
    //设置prefix为空，indent为tab
	data, err := json.MarshalIndent(m, "", "\t")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

设置了indent参数后的运行结果：

{
	"Go Ation": 2,
    "Go从入门到精通": 3,
    "Go入门": 1,
    "Go高级编程": 4
}

json.Unmarshal

json包的Unmarshal()函数作用与Marshal刚好相反，用于将一个JSON数据格式反序列化到一个我们定义好的Go类型变量中，该函数的签名如下所示：

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

下面是一个反序列化的示例：

package main

import (
	"encoding/json"
	"fmt"
)

type Book struct {
	BookName string `json:"name"`
	Number   int    `json:"num"`
}

func main() {
	jsonStr := `[{"name":"Go入门","num": 1}, {"name":"Go Ation","num": 2}, {"name":"Go从入门到精通","num": 3}, {"name":"Go高级编程","num": 4}]`

	var books []Book
	err := json.Unmarshal([]byte(jsonStr), &books)
	if err != nil {
		panic(err)
	}
	fmt.Println(books)
}

上面的例子中，我们将一个JSON反序化到一个数组当中，而该数组的元素是一个自定义的struct类型，在struct中可以通过json tag来定义json的字段名称。

自定义序列化

如果是自定义的数据类型，我们可以实现Marshaler接口和Unmarshaler接口的方法，这两个接口的定义如下：

type Unmarshaler interface {
	UnmarshalJSON([]byte) error
}

type Marshaler interface {
	MarshalJSON() ([]byte, error)
}

当调用Marshal函数序列化时，会调用MarshalJSON()函数，我们可以在该函数中自定义序列化的逻辑：

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Reason uint8

const (
	Unknown = iota
	Spring
	Summer
	Autumn
	Winter
)

//自定义反序列逻辑
func (r *Reason) UnmarshalJSON(b []byte) error {
	var s string
	if err := json.Unmarshal(b, &s); err != nil {
		return err
	}
	switch strings.ToLower(s) {
	default:
		*r = Unknown
	case "spring":
		*r = Spring
	case "summer":
		*r = Summer
	case "autumn":
		*r = Autumn
	case "winter":
		*r = Winter
	}

	return nil
}

//自定义序列逻辑
func (r Reason) MarshalJSON() ([]byte, error) {
	var s string
	switch r {
	default:
		s = "unknonw"
	case Spring:
		s = "spring"
	case Summer:
		s = "summer"
	case Autumn:
		s = "autumn"
	case Winter:
		s = "winter"
	}

	return json.Marshal(s)
}

func main() {
	r := []Reason{1, 2, 3, 4}
	data, err := json.Marshal(r)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

上面的代码中，Reason也实现了Unmarshaler接口，因此在调用Unmarshal函数反序列化时会调用UnmarshalJSON，在该方法中我们可以自定义反序列化的逻辑：

func main() {
	jsonStr := `["winter","spring","test"]`
	var r []Reason
	err := json.Unmarshal([]byte(jsonStr), &r)

	if err != nil {
		panic(err)
	}
	fmt.Println(r)
}

Encoder与Decoder

调用Marshal只会返回一个字节数组，Unmarshal函数只能传入一个字节数组，如果我们想将序列化的数据写入到不同的地方(比如保存到一个文件中)，或者想从不同地方读取JSON数据(比如从一个文件读取)，那么用Encoder和Decoder会更方便。

json.Encoder

NewEncoder函数可以创建一个Encoder结构体，NewEncoder函数接收一个实现了io.Writer接口的参数，在序列化后会调用io.Writer写入数据：

package main

import (
	"encoding/json"
	"os"
)

func main() {
	m := map[string]int{"Go入门": 1, "Go Ation": 2, "Go从入门到精通": 3, "Go高级编程": 4}
	file, err := os.Create("config.json")
	if err != nil {
		panic(err)
	}
    defer file.Close()
	encoder := json.NewEncoder(file)
	encoder.SetIndent("", "\t")
	err = encoder.Encode(m)

	if err != nil {
		panic(err)
	}
}

上面程序运行后，会把JSON数据保存到当前目录的config.json文件当中。

json.Decoder

NewDecoder函数可以创建一个Decoder结构体，NewDecoder函数接收一个实现了io.Reader接口的参数，也就是说Decoder从io.Reader中读取数据：

package main

import (
	"encoding/json"
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("config.json")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	decoder := json.NewDecoder(file)
	var m map[string]int
	err = decoder.Decode(&m)
	if err != nil {
		panic(err)
	}
	fmt.Println(m)
}

小结

JSON是一种非常通用的数据格式，经常被用于前后端api接口的数据通信，而Go语言在标准库encoding/json包中为JSON数据的编码与反编码提供非常好的支持。

好了，相信看完这篇文章，你应该掌握了以下几点了吧：

  • 什么是JSON
  • 如何序列化与反序列化JSON数据
  • 如何自定义序列化过程
  • json.Encoder与json.Decoder的使用