JSON 和 Go

本文为官方 Go Blog 的中文翻译，详见 翻译说明

Andrew Gerrand
2011 年 1 月 25 日

介绍#

JSON (JavaScript Object Notation) 是一种简洁的数据交换格式。从语法上讲，其类似于 JavaScript 的对象和列表。最常用于 Web 后端和浏览器中运行的 JavaScript 程序之间的通信，但也用于许多其他地方。它的主页，json.org 提供了一个清晰且简洁的标准定义.

使用 json 程序包 , 可以轻松地从 Go 程序中读取和写入 JSON 数据.

编码#

要编码 JSON 数据，我们可以使用 Marshal 函数.

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

给定 Go 数据结构 Message,

type Message struct {
    Name string
    Body string
    Time int64
}Copy

并实例化 Message

m := Message{"Alice", "Hello", 1294706395881547000}Copy

我们可以使用 json.Marshal 封装 m 的 JSON 编码版本:

b, err := json.Marshal(m)Copy

如果一切顺利，err 将为 nil 并且 b 将为包含以下 JSON 数据的一个 []byte:

b == []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)Copy

只有可以表示为有效 JSON 的数据结构才会被编码:

• JSON 对象仅支持将字符串作为键；要编码 Go 集合类型，它必须采用 map[string]T 的形式 (其中 T 是 json 程序包支持的任何 Go 类型).

• 无法对通道，复杂类型和函数类型进行编码.

• 不支持循环数据结构；它们会导致 Marshal 函数陷入无限循环.

• 指针将被编码为其指向的值 (如果指针为 nil 则为 'null').

程序包 json 仅访问结构类型 (以大写字母开头的结构类型) 的导出字段。因此，仅结构体的的可导出字段会出现在 JSON 输出中.

解码#

为了解码 JSON 数据，我们使用 Unmarshal 函数.

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

我们必须先创建一个存储解码数据的地方

var m MessageCopy

并调用 json.Unmarshal 函数，向其传递 JSON 数据的 []byte 和指向 m 的指针

err := json.Unmarshal(b, &m)Copy

如果 b 包含适用于 m 的有效 JSON, 则在调用 err 后将为 nil, 并且来自 b 将存储在结构 m 中，类似如下分配:

m = Message{
    Name: "Alice",
    Body: "Hello",
    Time: 1294706395881547000,
}Copy

Unmarshal 函数如何识别存储解码数据的字段？对于给定的 JSON 键 "Foo"，Unmarshal 将遍历目标结构的字段以查找 (按优先顺序):

• 标记为 "Foo" 的导出字段 (有关结构体标签的更多信息，请参见 Go 规定),
• 名为 "Foo" 的导出字段，或者
• 名为 "FOO" 或 "FoO" 的导出字段，或 "Foo" 的其他一些不区分大小写的匹配项.

当 JSON 数据的结构与 Go 类型不完全匹配时会发生什么？

b := []byte(`{"Name":"Bob","Food":"Pickle"}`)
var m Message
err := json.Unmarshal(b, &m)Copy

Unmarshal 函数将仅解码在目标类型中可以找到的字段。在这种情况下，将仅填充 m 的 Name 字段，而 Food 字段将被忽略。当您希望从大型 JSON Blob 中仅选择几个特定字段时，此行为特别有用。这也意味着目标结构体中任何未导出的字段都不会受到 Unmarshal 的影响.

但是，如果您事先不知道 JSON 数据的结构时怎么办？

带 interface {} 的通用 JSON#

interface{} (空接口) 类型描述了一个零方法的接口。每个 Go 类型都至少实现零个方法，因此满足空接口.

空接口用作常规容器类型:

var i interface{}
i = "a string"
i = 2011
i = 2.777Copy

类型断言访问基础的具体类型:

r := i.(float64)
fmt.Println("the circle's area", math.Pi*r*r)Copy

或者，如果基础类型未知，则由类型开关确定类型:

switch v := i.(type) {
case int:
    fmt.Println("twice i is", v*2)
case float64:
    fmt.Println("the reciprocal of i is", 1/v)
case string:
    h := len(v) / 2
    fmt.Println("i swapped by halves is", v[h:]+v[:h])
default:
    // i isn't one of the types above
}Copy

程序包 json 使用 map[string]interface{} 和 []interface{} 值存储任意 JSON 对象和数组；它将很乐意将任何有效的 JSON Blob 解组为一个简单的 interface{} 值。默认的具体 Go 类型是:

• bool 对照为 JSON 布尔值，
• float64 对照为 JSON 数值，
• string 对照为 JSON 字符串，以及
• nil 对照为 JSON 空.

解码任意数据#

考虑一下存储在变量 b 中的 JSON 数据:

b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)Copy

在不知道此数据结构的情况下，我们可以使用 Unmarshal 将其解码为 interface{} 值:

var f interface{}
err := json.Unmarshal(b, &f)Copy

此时 f 中的 Go 值将是一个集合，其键为字符串，其值本身存储为空接口值:

f = map[string]interface{}{
    "Name": "Wednesday",
    "Age":  6,
    "Parents": []interface{}{
        "Gomez",
        "Morticia",
    },
}Copy

要访问此数据我们可以使用类型断言来访问 f 的 map[string]interface{}:

m := f.(map[string]interface{})Copy

然后我们可以使用 range 语句遍历集合，并使用类型开关将其值作为其具体类型来访问:

for k, v := range m {
    switch vv := v.(type) {
    case string:
        fmt.Println(k, "is string", vv)
    case float64:
        fmt.Println(k, "is float64", vv)
    case []interface{}:
        fmt.Println(k, "is an array:")
        for i, u := range vv {
            fmt.Println(i, u)
        }
    default:
        fmt.Println(k, "is of a type I don't know how to handle")
    }
}Copy

这样您就可以使用未知的 JSON 数据，同时仍然享有类型安全的好处.

引用类型#

让我们定义一个 Go 类型以包含上一个示例中的数据:

type FamilyMember struct {
    Name    string
    Age     int
    Parents []string
}

    var m FamilyMember
    err := json.Unmarshal(b, &m)Copy

将数据解封为 FamilyMember 值可以按预期工作，但是如果仔细观察，我们可以看到发生了一件了不起的事情。通过 var 语句，我们分配了一个 FamilyMember 结构，然后将指向该值的指针提供给 Unmarshal 函数，但是那时 Parents 字段是一个 nil 切片值。为了填充 Parents 字段，Unmarshal 函数在幕后分配了一个新切片。这就是 Unmarshal 函数如何与支持的引用类型 (指针，切片和集合) 一起使用的典型方法.

考虑解封到此数据结构中:

type Foo struct {
    Bar *Bar
}Copy

如果 JSON 对象中有一个 Bar 字段，则 Unmarshal 将分配一个新的 Bar 并填充它。如果不是，Bar 将保留为 nil 指针.

由此产生一种有用的模式：如果您的应用程序接收一些不同的消息类型，则可以定义 "接收器" 结构，例如

type IncomingMessage struct {
    Cmd *Command
    Msg *Message
}Copy

发送方可以根据他们想要传达的消息类型来填充 Cmd 字段和 / 或顶级 JSON 对象的 Msg 字段。当将 JSON 解码为 IncomingMessage 结构时，Unmarshal 仅将分配存在于 JSON 数据中的数据结构。要知道要处理哪些消息，程序员只需测试 Cmd 或 Msg 不是 nil.

流失编码器和解码器#

程序包 json 提供 Decoder 和 Encoder 类型来支持读取和写入 JSON 数据流的通用操作. NewDecoder 和 NewEncoder 函数包装了 io.Reader 和 io.Writer 接口类型.

func NewDecoder(r io.Reader) *Decoder
func NewEncoder(w io.Writer) *EncoderCopy

这是一个示例程序，该程序从标准输入读取一系列 JSON 对象，从每个对象中删除了除 Name 字段之外的所有字段，然后将这些对象写入标准输出:

package main

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

func main() {
    dec := json.NewDecoder(os.Stdin)
    enc := json.NewEncoder(os.Stdout)
    for {
        var v map[string]interface{}
        if err := dec.Decode(&v); err != nil {
            log.Println(err)
            return
        }
        for k := range v {
            if k != "Name" {
                delete(v, k)
            }
        }
        if err := enc.Encode(&v); err != nil {
            log.Println(err)
        }
    }
}Copy

由于读取器和写入器无处不在，因此这里的 Encoder 和 Decoder 类型可以在广泛的场景中使用，例如对 HTTP 连接，WebSocket 或文件的读写.

引用#

有关更多信息可参阅 json 程序包文档. 有关 json 程序包的用法可参阅 jsonrpc 程序包.

本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 CC 协议，如果我们的工作有侵犯到您的权益，请及时联系我们。

原文地址：https://learnku.com/docs/go-blog/json-an...

译文地址：https://learnku.com/docs/go-blog/json-an...