Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go JSON

重学Go语言之JSON操作详解

作者:程序员读书

JSON的全称是Javascript Object Notation,是一种数据结构化交互的标准协议,这篇文章主要是来和大家介绍一下Go语言中JSON的相关操作,需要的可以参考下

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

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

JSON

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

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

JSON的数据类型

JSON只支持六种数据类型,分别是:

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

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函数可以接收一个prefixindent,用于设置输出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数据(比如从一个文件读取),那么用EncoderDecoder会更方便。

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接口的参数,也就是说Decoderio.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数据的编码与反编码提供非常好的支持。

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

到此这篇关于重学Go语言之JSON操作详解的文章就介绍到这了,更多相关Go JSON内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文