encoding/json

Package json

• import "encoding/json"

• 概述

• 索引

• 示例

概述

Json包 实现了 RFC 4627 中定义的 JSON 的编码和解码。JSON 和 Go值之间的映射在 Marshal 和 Unmarshal 函数的文档中进行了描述。

有关此包的介绍，请参阅“JSON和Go”：https：//golang.org/doc/articles/json_and_go.html

示例（CustomMarshalJSON）

package main

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

type Animal int

const (
	Unknown Animal = iota
	Gopher
	Zebra
)

func (a *Animal) UnmarshalJSON(b []byte) error {
	var s string
	if err := json.Unmarshal(b, &s err != nil {
		return err
	}
	switch strings.ToLower(s) {
	default:
		*a = Unknown
	case "gopher":
		*a = Gopher
	case "zebra":
		*a = Zebra
	}

	return nil
}

func (a Animal) MarshalJSON() ([]byte, error) {
	var s string
	switch a {
	default:
		s = "unknown"
	case Gopher:
		s = "gopher"
	case Zebra:
		s = "zebra"
	}

	return json.Marshal(s)
}

func main() {
	blob := `["gopher","armadillo","zebra","unknown","gopher","bee","gopher","zebra"]`
	var zoo []Animal
	if err := json.Unmarshal([]byte(blob), &zoo err != nil {
		log.Fatal(err)
	}

	census := make(map[Animal]int)
	for _, animal := range zoo {
		census[animal] += 1
	}

	fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",
		census[Gopher], census[Zebra], census[Unknown])

}

索引

• func Compact(dst *bytes.Buffer, src []byte) error

• func HTMLEscape(dst *bytes.Buffer, src []byte)

• func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error

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

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

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

• func Valid(data []byte) bool

• type Decoder

• func NewDecoder(r io.Reader) *Decoder

• func (dec *Decoder) Buffered() io.Reader

• func (dec *Decoder) Decode(v interface{}) error

• func (dec *Decoder) More() bool

• func (dec *Decoder) Token() (Token, error)

• func (dec *Decoder) UseNumber()

• type Delim

• func (d Delim) String() string

• type Encoder

• func NewEncoder(w io.Writer) *Encoder

• func (enc *Encoder) Encode(v interface{}) error

• func (enc *Encoder) SetEscapeHTML(on bool)

• func (enc *Encoder) SetIndent(prefix, indent string)

• type InvalidUTF8Error

• func (e *InvalidUTF8Error) Error() string

• type InvalidUnmarshalError

• func (e *InvalidUnmarshalError) Error() string

• type Marshaler

• type MarshalerError

• func (e *MarshalerError) Error() string

• type Number

• func (n Number) Float64() (float64, error)

• func (n Number) Int64() (int64, error)

• func (n Number) String() string

• type RawMessage

• func (m RawMessage) MarshalJSON() ([]byte, error)

• func (m *RawMessage) UnmarshalJSON(data []byte) error

• type SyntaxError

• func (e *SyntaxError) Error() string

• type Token

• type UnmarshalFieldError

• func (e *UnmarshalFieldError) Error() string

• type UnmarshalTypeError

• func (e *UnmarshalTypeError) Error() string

• type Unmarshaler

• type UnsupportedTypeError

• func (e *UnsupportedTypeError) Error() string

• type UnsupportedValueError

• func (e *UnsupportedValueError) Error() string

示例

Decoder Decoder.Decode (Stream) Decoder.Token Indent Marshal RawMessage (Marshal) RawMessage (Unmarshal) Unmarshal Package (CustomMarshalJSON)

包文件

decode.go encode.go fold.go indent.go scanner.go stream.go tables.go tags.go

func Compact（查看源代码）

func Compact(dst *bytes.Buffer, src []byte) error

紧凑追加到 JSON 编码的 src 中，而忽略空间字符。

func HTMLEscape（查看源代码）

func HTMLEscape(dst *bytes.Buffer, src []byte)

HTMLEscape 将 dst JSON 编码的 src 与字符串文字中的<，>，＆ U + 2028 和 U + 2029 字符更改为 \u003c，\u003e，\u0026，\u2028，\u2029，以便 JSON 安全嵌入 HTML<script> 标签内。由于历史原因，Web 浏览器不遵守 <script> 标签内的标准 HTML 转义，因此必须使用替代的 JSON 编码。

func Indent（查看源代码）

func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error

缩进附加到 JSON 编码的 src 的缩进形式的 dst。JSON 对象或数组中的每个元素都以一个新的缩进行开始，该行以前缀开头，随后是根据缩进嵌套的一个或多个缩进副本。追加到 dst 的数据不是以前缀或任何缩进开头，以便更容易嵌入其他格式化的 JSON 数据中。尽管 src 开头的空格字符（空格，制表符，回车符，换行符）被删除，但 src 末尾的空格符被保留并复制到 dst。例如，如果 src 没有尾随空格，则 dst；如果 src 以结尾的换行符结束，那么 dst。

示例

package main

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

func main() {
	type Road struct {
		Name   string
		Number int
	}
	roads := []Road{
		{"Diamond Fork", 29},
		{"Sheep Creek", 51},
	}

	b, err := json.Marshal(roads)
	if err != nil {
		log.Fatal(err)
	}

	var out bytes.Buffer
	json.Indent(&out, b, "=", "\t")
	out.WriteTo(os.Stdout)
}

func Marshal（查看源代码）

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

Marshal 返回 v 的 JSON 编码。

marshal 递归地遍历值 v。如果遇到的值实现了 Marshaler 接口并且不是零指针，则 Marshal 会调用其 MarshalJSON 方法生成 JSON。如果没有 MarshalJSON 方法存在，但该值实现的是 encoding.TextMarshaler，Marshal 会调用它的 MarshalText 方法并将结果编码为 JSON 字符串。nil 指针异常并不是绝对必要的，但它模仿了 UnmarshalJSON 行为中类似的必要异常。

否则，Marshal 将使用以下依赖于类型的默认编码：

布尔值编码为 JSON 布尔值。

浮点数，整数和数字值编码为 JSON 数字。

字符串值被编码为强制为有效 UTF-8 的 JSON 字符串，用 Unicode 替换符号替换无效字节。尖括号“<”和“>”会转义为“\u003c”和“\u003e”，以防止某些浏览器将 JSON 输出误解为 HTML。出于同样的原因，＆ 符号“＆”也会转义为“\u0026”。这个转义可以通过使用一个具有 SetEscapeHTML(false) 的编码器来禁用。

数组和切片值的编码方式为 JSON 数组，不同之处在于 []byte 编码为 base64 编码的字符串，而无切片编码为空 JSON 值。

结构值编码为 JSON 对象。除非由于下面给出的原因之一而忽略该字段，否则每个导出的结构字段都将成为对象的成员，并使用字段名称作为对象键。

每个结构字段的编码可以通过结构字段标签中“json”键下存储的格式字符串来定制。格式字符串给出字段的名称，可能后跟逗号分隔的选项列表。名称可能为空，以指定选项而不覆盖默认字段名称。

“omitempty”选项指定如果字段具有空值，定义为false，0，零指针，nil 接口值以及任何空数组，切片，映射或字符串，则该字段应从编码中省略。

作为特殊情况，如果字段标签是“ - ”，则该字段总是被省略。请注意，名称为“ - ”的字段仍然可以使用标签“ - ，”生成。

结构域标签及其含义的示例：

// 字段在JSON中显示为关键字“myName”。
Field int `json:"myName"`

// 字段在JSON中显示为关键字“myName”和
// 如果该值为空，则从该对象中省略该字段，
// 如上所述。
Field int `json:"myName,omitempty"`

// 字段在JSON中显示为键“Field”（默认值），但是
// 如果为空，则跳过该字段。
// 请注意主要逗号。
Field int `json:",omitempty"`

// 该包忽略该字段。
Field int `json:"-"`

// 字段在JSON中显示为键“ - ”。
Field int `json:"-,"`

“string”选项表示字段在 JSON 编码的字符串内以 JSON 形式存储。它仅适用于字符串，浮点，整数或布尔类型的字段。与 JavaScript 程序通信时，有时会使用这种额外的编码级别：

Int64String int64 `json:",string"`

如果密钥名称是非空字符串，只包含 Unicode 引号，数字和 ASCII 标点符号（引号，反斜杠和逗号除外），则使用该名称。

匿名结构字段通常会封送，就好像它们的内部导出字段是外部结构中的字段一样，受限于通常的 Go 可见性规则，如下一段所述。具有在其 JSON 标签中给出的名称的匿名结构字段被视为具有该名称，而不是匿名的。接口类型的匿名结构字段被视为具有该类型作为它的名称，而不是匿名。

在决定将哪个字段编组或解组时，修改 JSON 的结构字段的 Go 可见性规则。如果在同一级别有多个字段，并且该级别嵌套最少（因此将成为通常的 Go 规则选择的嵌套级别），则适用以下额外规则：

1）在这些字段中，如果有任何字段是 JSON 标记的，则仅考虑标记字段，即使存在多个否则会发生冲突的未标记字段。

2）如果只有一个字段（根据第一条规则标记或不标记），则选择该字段。

3）否则有多个字段，全部被忽略；没有错误发生。

处理匿名结构字段在 Go 1.1 中是新的。在 Go 1.1 之前，匿名结构字段被忽略。要强制忽略当前版本和早期版本中的匿名结构字段，请为该字段指定一个“ - ”的 JSON 标记。

地图值编码为 JSON 对象。该映射的键类型必须是一个字符串，一个整数类型或实现 encoding.TextMarshaler。通过应用以下规则，映射键被排序并用作 JSON 对象键，这些规则受上述字符串值描述的 UTF-8 强制的约束：

 - 直接使用字符串键
-  encoding.TextMarshalers被封送
- 整数键转换为字符串

指针值按照指向的值进行编码。零指针编码为空 JSON 值。

接口值编码为接口中包含的值。一个无接口值编码为空 JSON 值。

通道，complex 和函数值不能用 JSON 编码。尝试对这种值进行编码会导致 Marshal 返回一个 UnsupportedTypeError。

JSON 不能表示循环数据结构，而 Marshal 不处理它们。将循环结构传递给 Marshal 将导致无限递归。

示例

package main

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

func main() {
	type ColorGroup struct {
		ID     int
		Name   string
		Colors []string
	}
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
	}
	b, err := json.Marshal(group)
	if err != nil {
		fmt.Println("error:", err)
	}
	os.Stdout.Write(b)
}

func MarshalIndent（查看源代码）

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

MarshalIndent 与 Marshal 类似，但应用缩进来格式化输出。

func Unmarshal（查看源代码）

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

Unmarshal 解析 JSON 编码数据并将结果存储在v指向的值中。如果v是零或不是指针，Unmarshal 将返回一个 InvalidUnmarshalError。

Unmarshal 使用 Marshal 使用的编码的逆矩阵，根据需要分配地图，切片和指针，并使用以下附加规则：

要将 JSON 解组为一个指针，Unmarshal 首先处理 JSON 为 JSON literal 的情况。在这种情况下，Unmarshal 将指针设置为 nil。否则，Unmarshal 会将 JSON 解组为指针指向的值。如果指针为零，Unmarshal 会为它指定一个新值。

要将 JSON 解组为一个实现 Unmarshaler 接口的值，Unmarshal 调用该值的 UnmarshalJSON 方法，包括输入为 JSON null 时的情况。否则，如果值实现了 encoding.TextUnmarshaler 并且输入是 JSON 带引号的字符串，则 Unmarshal 会使用该字符串的不带引号的形式调用该值的 UnmarshalText 方法。

要将 JSON 解组到一个结构中，Unmarshal 会将传入的对象键与 Marshal 所使用的键（结构字段名称或其标记）进行匹配，而不是匹配完全匹配，但也会接受不区分大小写的匹配。Unmarshal 只会设置结构的导出字段。

要将 JSON 解组为接口值，Unmarshal 将其中一个存储在接口值中：

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

要将 JSON 数组解封片，Unmarshal 将片长度重置为零，然后将每个元素追加到片中。作为一种特殊情况，为了将空 JSON 数组解组成一个片，Unmarshal 用一个新的空片替换该片。

为了将 JSON 数组解组为一个 Go 数组，Unmarshal 将 JSON 数组元素解码为相应的 Go 数组元素。如果 Go 数组小于 JSON 数组，则会放弃其他 JSON 数组元素。如果 JSON 数组小于 Go 数组，则额外的 Go 数组元素将设置为零值。

为了将 JSON 对象解组映射到地图，Unmarshal 首先建立一个要使用的地图。如果地图为零，Unmarshal 会分配一个新地图。否则 Unmarshal 将重新使用现有的地图，保留现有的条目。Unmarshal 然后将来自 JSON 对象的键值对存储到地图中。映射的键类型必须是一个字符串，一个整数，或实现 encoding.TextUnmarshaler。

如果 JSON 值不适合给定的目标类型，或者 JSON 数字溢出目标类型，则 Unmarshal 会跳过该字段并尽可能完成解组。如果没有遇到更严重的错误，Unmarshal 将返回一个描述最早此类错误的 UnmarshalTypeError。在任何情况下，都不能保证有问题的后面的所有剩余字段将被解组到目标对象中。

通过将 Go 值设置为 nil，JSON null 值解组成接口，映射，指针或片。因为 JSON 中常常使用 null 来表示“not present”，所以将 JSON null 解组为任何其他 Go 类型对该值没有影响，并且不会产生错误。

解组引用的字符串时，无效的 UTF-8 或无效的 UTF-16 代理对不会被视为错误。相反，它们被替换为 Unicode 替换字符 U + FFFD。

示例

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var jsonBlob = []byte(`[
		{"Name": "Platypus", "Order": "Monotremata"},
		{"Name": "Quoll",    "Order": "Dasyuromorphia"}
	]`)
	type Animal struct {
		Name  string
		Order string
	}
	var animals []Animal
	err := json.Unmarshal(jsonBlob, &animals)
	if err != nil {
		fmt.Println("error:", err)
	}
	fmt.Printf("%+v", animals)
}

func Valid（查看源代码）

func Valid(data []byte) bool

有效报告数据是否是有效的 JSON 编码。

type Decoder（查看源代码）

解码器从输入流中读取和解码 JSON 值。

type Decoder struct {
        // 包含已过滤或未导出的字段
}

示例

本示例使用 Decoder 来解码不同 JSON 值的流。

package main

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

func main() {
	const jsonStream = `
		{"Name": "Ed", "Text": "Knock knock."}
		{"Name": "Sam", "Text": "Who's there?"}
		{"Name": "Ed", "Text": "Go fmt."}
		{"Name": "Sam", "Text": "Go fmt who?"}
		{"Name": "Ed", "Text": "Go fmt yourself!"}
	`
	type Message struct {
		Name, Text string
	}
	dec := json.NewDecoder(strings.NewReader(jsonStream))
	for {
		var m Message
		if err := dec.Decode(&m err == io.EOF {
			break
		} else if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%s: %s\n", m.Name, m.Text)
	}
}

func NewDecoder（查看源代码）

func NewDecoder(r io.Reader) *Decoder

NewDecoder 返回从 r 读取的新解码器。

解码器引入了自己的缓冲区，并且可以读取超出请求的 JSON 值的r数据。

func (*Decoder) Buffere（查看源代码）

func (dec *Decoder) Buffered() io.Reader

缓冲返回解码器缓冲区中剩余数据的阅读器。直到下一次调用 Decode，读卡器才有效。

func (*Decoder) Decode（查看源代码）

func (dec *Decoder) Decode(v interface{}) error

解码从其输入读取下一个 JSON 编码的值，并将其存储在 v 指向的值中。

有关将 JSON 转换为 Go 值的详细信息，请参阅 Unmarshal 的文档。

示例（Stream）

本示例使用 Decoder 解码 JSON 对象的流数组。

package main

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

func main() {
	const jsonStream = `
	[
		{"Name": "Ed", "Text": "Knock knock."},
		{"Name": "Sam", "Text": "Who's there?"},
		{"Name": "Ed", "Text": "Go fmt."},
		{"Name": "Sam", "Text": "Go fmt who?"},
		{"Name": "Ed", "Text": "Go fmt yourself!"}
	]
`
	type Message struct {
		Name, Text string
	}
	dec := json.NewDecoder(strings.NewReader(jsonStream))

	// 读开括号
	t, err := dec.Token()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%T: %v\n", t, t)

	// 而数组包含值
	for dec.More() {
		var m Message
		// 解码数组值（Message）
		err := dec.Decode(&m)
		if err != nil {
			log.Fatal(err)
		}

		fmt.Printf("%v: %v\n", m.Name, m.Text)
	}

	// 阅读结束括号
	t, err = dec.Token()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%T: %v\n", t, t)

}

func (*Decoder) More（查看源代码）

func (dec *Decoder) More() bool

更多报告当前数组或对象是否有另一个元素被解析。

func (*Decoder) Token（查看源代码）

func (dec *Decoder) Token() (Token, error)

令牌返回输入流中的下一个 JSON 令牌。在输入流结束时，令牌返回 nil，io.EOF。

令牌保证它返回的分隔符正确嵌套和匹配：如果令牌在输入中遇到意外的分隔符，它将返回一个错误。

输入流包含基本的 JSON 值（bool，string，number和null）以及Delim 类型的分隔符 {}，以标记数组和对象的开始和结束。逗号和冒号被忽略。

示例

本示例使用 Decoder 来解码不同 JSON 值的流。

package main

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

func main() {
	const jsonStream = `
		{"Message": "Hello", "Array": [1, 2, 3], "Null": null, "Number": 1.234}
	`
	dec := json.NewDecoder(strings.NewReader(jsonStream))
	for {
		t, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%T: %v", t, t)
		if dec.More() {
			fmt.Printf(" (more)")
		}
		fmt.Printf("\n")
	}
}

func (*Decoder) UseNumber（查看源代码）

func (dec *Decoder) UseNumber()

UseNumber让解码器将数字解组到interface{}中，而不是float64

type Delim（查看源代码）

Delim 是 JSON 数组或对象分隔符，即 { 或 } 之一。

type Delim rune

func (Delim) String（查看源代码）

func (d Delim) String() string

type Encoder（查看源代码）

编码器将 JSON 值写入输出流。

type Encoder struct {
        // 包含已过滤或未导出的字段
}

func NewEncoder（查看源代码）

func NewEncoder(w io.Writer) *Encoder

NewEncoder 返回一个写入 w 的新编码器。

func (*Encoder) Encode（查看源代码）

func (enc *Encoder) Encode(v interface{}) error

编码将 v 的 JSON 编码写入流中，后跟一个换行符。

有关将 Go 值转换为 JSON 的详细信息，请参阅 Marshal 的文档。

func (*Encoder) SetEscapeHTML（查看源代码）

func (enc *Encoder) SetEscapeHTML(on bool)

SetEscapeHTML 指定是否应在 JSON 引用字符串内转义有问题的 HTML 字符。默认行为是将＆，<和>转义为 \u0026，\u003c 和\u003e，以避免将 JSON 嵌入到 HTML 中时可能出现的某些安全问题。

在非 HTML 设置中，转义会干扰输出的可读性，SetEscapeHTML(false) 会禁用此行为。

func (*Encoder) SetIndent（查看源代码）

func (enc *Encoder) SetIndent(prefix, indent string)

SetIndent 指示编码器对每个后续编码值进行格式化，就像由包级函数Indent（dst，src，prefix，indent）缩进一样。调用 SetIndentt("", "") 将禁用缩进。

type InvalidUTF8Error（查看源代码）

在 Go 1.2 之前，Marshal在尝试使用无效的 UTF-8 序列对字符串值进行编码时返回了 InvalidUTF8Error。从 Go 1.2 开始，Marshal 会将字符串替换为有效的 UTF-8，方法是用 Unicode 替换符号 U + FFFD 替换无效字节。这个错误不再生成，而是为了向后兼容可能提及它的程序而保留。

type InvalidUTF8Error struct {
        S string // 导致错误的整个字符串值
}

func (*InvalidUTF8Error) Error（查看源代码）

func (e *InvalidUTF8Error) Error() string

type InvalidUnmarshalError（查看源代码）

InvalidUnmarshalError 描述传递给 Unmarshal 的无效参数。（Unmarshal 的参数必须是非零指针。）

type InvalidUnmarshalError struct {
        Type reflect.Type
}

func (*InvalidUnmarshalError) Error（查看源代码）

func (e *InvalidUnmarshalError) Error() string

type Marshaler（查看源代码）

Marshaler 是由可以将自己编组为有效 JSON 的类型实现的接口。

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

type MarshalerError（查看源代码）

type MarshalerError struct {
        Type reflect.Type
        Err  error
}

func (*MarshalerError) Error（查看源代码）

func (e *MarshalerError) Error() string

type Number（查看源代码）

数字表示 JSON 数字文字。

type Number string

func (Number) Float64（查看源代码）

func (n Number) Float64() (float64, error)

Float64 将该数字作为 float64 返回。

func (Number) Int64（查看源代码）

func (n Number) Int64() (int64, error)

Int64 将该数字作为 int64 返回。

func (Number) String（查看源代码）

func (n Number) String() string

字符串返回数字的文本文本。

type RawMessage（查看源代码）

RawMessae 是一个原始编码的 JSON 值。它实现了 Marshaler 和 Unmarshaler，可用于延迟 JSON 解码或预先计算 JSON 编码。

type RawMessage []byte

示例（Marshal）

这个例子使用 RawMessage 在编组期间使用预先计算的 JSON。

package main

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

func main() {
	h := json.RawMessage(`{"precomputed": true}`)

	c := struct {
		Header *json.RawMessage `json:"header"`
		Body   string           `json:"body"`
	}{Header: &h, Body: "Hello Gophers!"}

	b, err := json.MarshalIndent(&c, "", "\t")
	if err != nil {
		fmt.Println("error:", err)
	}
	os.Stdout.Write(b)

}

示例（Unmarshal）

本示例使用 RawMessage 延迟解析 JSON 消息的一部分。

package main

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

func main() {
	type Color struct {
		Space string
		Point json.RawMessage // 延迟解析直到我们知道color space
	type RGB struct {
		R uint8
		G uint8
		B uint8
	}
	type YCbCr struct {
		Y  uint8
		Cb int8
		Cr int8
	}

	var j = []byte(`[
		{"Space": "YCbCr", "Point": {"Y": 255, "Cb": 0, "Cr": -10}},
		{"Space": "RGB",   "Point": {"R": 98, "G": 218, "B": 255}}
	]`)
	var colors []Color
	err := json.Unmarshal(j, &colors)
	if err != nil {
		log.Fatalln("error:", err)
	}

	for _, c := range colors {
		var dst interface{}
		switch c.Space {
		case "RGB":
			dst = new(RGB)
		case "YCbCr":
			dst = new(YCbCr)
		}
		err := json.Unmarshal(c.Point, dst)
		if err != nil {
			log.Fatalln("error:", err)
		}
		fmt.Println(c.Space, dst)
	}
}

func (RawMessage) MarshalJSON（查看源代码）

func (m RawMessage) MarshalJSON() ([]byte, error)

MarshalJSON 返回 m 作为 m 的 JSON 编码。

func (*RawMessage) UnmarshalJSON（查看源代码）

func (m *RawMessage) UnmarshalJSON(data []byte) error

UnmarshalJSON 将 *m 设置为数据副本。

type SyntaxError（查看源代码）

SyntaxError 是对 JSON 语法错误的描述。

type SyntaxError struct {
        Offset int64 // 读取偏移字节后发生错误
        // 包含已过滤或未导出的字段
}

func (*SyntaxError) Error（查看源代码）

func (e *SyntaxError) Error() string

type Token（查看源代码）

令牌具有以下其中一种类型的值：

Delim，用于四个JSON分隔符[] {}
bool，用于JSON布尔
float64，用于JSON数字
数字，用于JSON数字
string，用于JSON字符串文字
nil，对于JSON null

type Token interface{}

type UnmarshalFieldError（查看源代码）

UnmarshalFieldError 描述了导致未导出（因此不可写）结构字段的 JSON 对象键。（不再使用；保持兼容性。）

type UnmarshalFieldError struct {
        Key   string
        Type  reflect.Type
        Field reflect.StructField
}

func (*UnmarshalFieldError) Error（查看源代码）

func (e *UnmarshalFieldError) Error() string

type UnmarshalTypeError（查看源代码）

UnmarshalTypeError 描述的 JSON 值不适合特定 Go 类型的值。

type UnmarshalTypeError struct {
        Value  string       // JSON值的描述 - “bool”，“array”，“number -5”
        Type   reflect.Type // 无法分配的Go值类型
        Offset int64        // 读取偏移字节后发生错误
        Struct string       // 包含该字段的结构类型的名称
        Field  string       // 保持Go值的字段的名称
}

func (*UnmarshalTypeError) Error（查看源代码）

func (e *UnmarshalTypeError) Error() string

type Unmarshaler（查看源代码）

Unmarshaler 是由可以解组自己的 JSON 描述的类型实现的接口。输入可以被假定为 JSON 值的有效编码。如果它希望在返回后保留数据，则 UnmarshalJSON 必须复制 JSON 数据。

按照惯例，为了近似 Unmarshal 本身的行为，Unmarshalers 实现 UnmarshalJSON([]byte("null")) 作为 no-op。

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

type UnsupportedTypeError（查看源代码）

Marshal 在尝试对不支持的值类型进行编码时返回 UnsupportedTypeError。

type UnsupportedTypeError struct {
        Type reflect.Type
}

func (*UnsupportedTypeError) Error（查看源代码）

func (e *UnsupportedTypeError) Error() string

type UnsupportedValueError（查看源代码）

type UnsupportedValueError struct {
        Value reflect.Value
        Str   string
}

func (*UnsupportedValueError) Error（查看源代码）

func (e *UnsupportedValueError) Error() string