json

package
v1.21.10 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 7, 2024 License: MIT Imports: 3 Imported by: 0

Documentation

Overview

jsonパッケージは、RFC 7159で定義されているJSONのエンコーディングとデコーディングを実装します。 JSONとGoの値の間のマッピングは、Marshal関数とUnmarshal関数のドキュメンテーションで説明されています。

このパッケージの紹介については、「JSONとGo」を参照してください： https://golang.org/doc/articles/json_and_go.html

Example (CustomMarshalJSON) 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
)

const (
	Unknown Animal = iota
	Gopher
	Zebra
)

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])

}

Output:

Zoo Census:
* Gophers: 3
* Zebras:  2
* Unknown: 3
Example (TextMarshalJSON) 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
)

const (
	Unrecognized Size = iota
	Small
	Large
)

func main() {
	blob := `["small","regular","large","unrecognized","small","normal","small","large"]`
	var inventory []Size
	if err := json.Unmarshal([]byte(blob), &inventory); err != nil {
		log.Fatal(err)
	}

	counts := make(map[Size]int)
	for _, size := range inventory {
		counts[size] += 1
	}

	fmt.Printf("Inventory Counts:\n* Small:        %d\n* Large:        %d\n* Unrecognized: %d\n",
		counts[Small], counts[Large], counts[Unrecognized])

}

Output:

Inventory Counts:
* Small:        3
* Large:        2
* Unrecognized: 3

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Compact 

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

Compactは、無意味なスペース文字が省略された、JSONエンコードされたsrcをdstに追加します。

func HTMLEscape 

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

HTMLEscapeは、JSONエンコードされたsrcをdstに追加します。ただし、文字列リテラル内の<, >, &, U+2028およびU+2029 文字は\u003c, \u003e, \u0026, \u2028, \u2029に変更されます。 これにより、JSONはHTMLの<script>タグ内に埋め込むのに安全になります。 歴史的な理由から、ウェブブラウザは<script>タグ内で標準的なHTMLエスケープを尊重しないため、 代替のJSONエンコーディングを使用する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/bytes"
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/os"
)

func main() {
	var out bytes.Buffer
	json.HTMLEscape(&out, []byte(`{"Name":"<b>HTML content</b>"}`))
	out.WriteTo(os.Stdout)
}

Output:

{"Name":"\u003cb\u003eHTML content\u003c/b\u003e"}

func Indent 

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

Indentは、JSONエンコードされたsrcのインデント形式をdstに追加します。 JSONオブジェクトまたは配列の各要素は、新しい、インデントされた行で始まり、 その行はprefixで始まり、インデントのネストに応じてindentの1つ以上のコピーが続きます。 dstに追加されるデータは、prefixやインデントで始まらないようになっています。 これにより、他のフォーマットされたJSONデータ内に埋め込むのが容易になります。 srcの先頭の空白文字（スペース、タブ、キャリッジリターン、改行）は削除されますが、 srcの末尾の空白文字は保持され、dstにコピーされます。 例えば、srcが末尾のスペースを持っていない場合、dstも持ちません。 srcが末尾の改行で終わる場合、dstも同様になります。

Example 
package main

import (
	"github.com/shogo82148/std/bytes"
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)
}

Output:

[
=	{
=		"Name": "Diamond Fork",
=		"Number": 29
=	},
=	{
=		"Name": "Sheep Creek",
=		"Number": 51
=	}
=]

func Marshal 

func Marshal(v any) ([]byte, error)

Marshalは、vのJSONエンコーディングを返します。

Marshalは、値vを再帰的に走査します。 もし遭遇した値がMarshalerインターフェースを実装しており、 それがnilポインタでない場合、MarshalはそのMarshalJSONメソッドを呼び出して JSONを生成します。MarshalJSONメソッドが存在しないが、 その値が代わりにencoding.TextMarshalerを実装している場合、Marshalは そのMarshalTextメソッドを呼び出し、その結果をJSON文字列としてエンコードします。 nilポインタの例外は厳密には必要ではありませんが、 UnmarshalJSONの振る舞いにおける同様の、必要な例外を模倣します。

それ以外の場合、Marshalは以下の型依存のデフォルトエンコーディングを使用します：

ブール値はJSONのブール値としてエンコードされます。

浮動小数点数、整数、およびNumberの値はJSONの数値としてエンコードされます。 NaNおよび+/-Infの値は[UnsupportedValueError]を返します。

文字列の値は、無効なバイトをUnicodeの置換文字に置き換えて、 有効なUTF-8に強制されたJSON文字列としてエンコードされます。 JSONがHTMLの<script>タグ内に埋め込んでも安全であるように、 文字列はHTMLEscapeを使用してエンコードされ、 "<", ">", "&", U+2028, および U+2029 が "\u003c","\u003e", "\u0026", "\u2028", および "\u2029" にエスケープされます。 この置換は、エンコーダを使用している場合、SetEscapeHTML(false)を呼び出すことで無効にできます。

配列とスライスの値はJSON配列としてエンコードされますが、 []byteはbase64エンコードされた文字列としてエンコードされ、 nilスライスはnullのJSON値としてエンコードされます。

構造体の値はJSONオブジェクトとしてエンコードされます。 エクスポートされた各構造体フィールドは、オブジェクトのメンバーとなり、 フィールド名がオブジェクトキーとして使用されます。ただし、以下に示す理由のいずれかでフィールドが省略される場合があります。

各構造体フィールドのエンコーディングは、構造体フィールドのタグの"json"キーの下に格納された フォーマット文字列によってカスタマイズできます。 フォーマット文字列はフィールド名を指定し、それに続いてカンマで区切られたオプションのリストが続く可能性があります。 デフォルトのフィールド名を上書きせずにオプションを指定するために、名前は空にすることができます。

"omitempty"オプションは、フィールドが空の値を持つ場合、 エンコーディングからそのフィールドを省略することを指定します。 空の値とは、false、0、nilポインタ、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) フィールドが1つだけ（最初のルールに従ってタグ付けされているかどうか）存在する場合、それが選択されます。

3) それ以外の場合、複数のフィールドが存在し、すべてが無視されます。エラーは発生しません。

匿名の構造体フィールドの扱いはGo 1.1で新しくなりました。 Go 1.1より前では、匿名の構造体フィールドは無視されていました。現在のバージョンと以前のバージョンの両方で 匿名の構造体フィールドを強制的に無視するには、フィールドにJSONタグ "-" を付けてください。

マップの値はJSONオブジェクトとしてエンコードされます。マップのキーの型は、 文字列、整数型、またはencoding.TextMarshalerを実装する必要があります。マップのキーは ソートされ、上記の文字列値に対するUTF-8の強制に従って、以下のルールを適用して JSONオブジェクトのキーとして使用されます：

  • 任意の文字列型のキーは直接使用されます
  • encoding.TextMarshalersはマーシャルされます
  • 整数キーは文字列に変換されます

ポインタ値は指している値としてエンコードされます。 nilポインタはnullのJSON値としてエンコードされます。

インターフェースの値は、インターフェースに含まれる値としてエンコードされます。 nilのインターフェース値は、nullのJSON値としてエンコードされます。

チャネル、複素数、および関数の値はJSONでエンコードすることはできません。 そのような値をエンコードしようとすると、Marshalは UnsupportedTypeErrorを返します。

JSONは循環データ構造を表現することはできませんし、Marshalはそれらを処理しません。 循環構造をMarshalに渡すとエラーが発生します。

Example 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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)
}

Output:

{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}

func MarshalIndent 

func MarshalIndent(v any, prefix, indent string) ([]byte, error)

MarshalIndentはMarshalと同様ですが、出力のフォーマットにIndentを適用します。 出力の各JSON要素は、インデントのネストに従ってprefixで始まり、 その後にindentの1つ以上のコピーが続く新しい行で始まります。

Example 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
)

func main() {
	data := map[string]int{
		"a": 1,
		"b": 2,
	}

	b, err := json.MarshalIndent(data, "<prefix>", "<indent>")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(b))
}

Output:

{
<prefix><indent>"a": 1,
<prefix><indent>"b": 2
<prefix>}

func Unmarshal 

func Unmarshal(data []byte, v any) error

Unmarshalは、JSONエンコードされたデータを解析し、結果をvが指す値に格納します。 もしvがnilまたはポインタでない場合、UnmarshalはInvalidUnmarshalErrorを返します。

Unmarshalは、Marshalが使用するエンコーディングの逆を使用し、 必要に応じてマップ、スライス、ポインタを割り当てます。 以下の追加ルールも適用されます：

JSONをポインタにアンマーシャルするために、Unmarshalはまず JSONがJSONリテラルnullであるケースを処理します。その場合、Unmarshalは ポインタをnilに設定します。それ以外の場合、UnmarshalはJSONを ポインタが指す値にアンマーシャルします。もしポインタがnilなら、Unmarshalは それが指す新しい値を割り当てます。

Unmarshalerインターフェースを実装する値にJSONをアンマーシャルするために、 Unmarshalはその値のUnmarshalJSONメソッドを呼び出します、 入力がJSON nullである場合も含みます。 それ以外の場合、もし値がencoding.TextUnmarshalerを実装していて、 入力がJSONの引用符で囲まれた文字列である場合、Unmarshalはその値の UnmarshalTextメソッドを引用符で囲まれていない形式の文字列で呼び出します。

JSONを構造体にアンマーシャルするために、Unmarshalは受信したオブジェクトの キーをMarshalが使用するキー（構造体のフィールド名またはそのタグ）と一致させます。 これは完全一致を優先しますが、大文字小文字を区別しない一致も受け入れます。 デフォルトでは、対応する構造体のフィールドがないオブジェクトのキーは無視されます （代替としてDecoder.DisallowUnknownFieldsを参照してください）。

インターフェース値に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はスライスを新しい空のスライスで置き換えます。

Goの配列にJSON配列をアンマーシャルするために、Unmarshalは JSON配列の要素を対応するGoの配列の要素にデコードします。 もしGoの配列がJSON配列より小さい場合、 追加のJSON配列の要素は破棄されます。 もしJSON配列がGoの配列より小さい場合、 追加のGoの配列の要素はゼロ値に設定されます。

JSONオブジェクトをマップにアンマーシャルするために、Unmarshalは最初に使用するマップを確立します。 マップがnilの場合、Unmarshalは新しいマップを割り当てます。それ以外の場合、Unmarshalは 既存のマップを再利用し、既存のエントリを保持します。次に、UnmarshalはJSONオブジェクトから キーと値のペアをマップに格納します。マップのキーの型は、任意の文字列型、整数、 json.Unmarshalerを実装するもの、またはencoding.TextUnmarshalerを実装するものでなければなりません。

もしJSONエンコードされたデータに構文エラーが含まれている場合、UnmarshalはSyntaxErrorを返します。

もしJSON値が特定のターゲット型に適していない場合、 またはJSON数値がターゲット型をオーバーフローする場合、Unmarshalは そのフィールドをスキップし、可能な限りアンマーシャルを完了します。 もしもっと深刻なエラーが発生しなければ、Unmarshalは最初のそのようなエラーを 説明するUnmarshalTypeErrorを返します。いずれにせよ、問題のあるフィールドに続く すべてのフィールドがターゲットオブジェクトにアンマーシャルされることは保証されません。

JSONのnull値は、そのGoの値をnilに設定することでインターフェース、マップ、ポインタ、スライスにアンマーシャルされます。 nullはJSONで「存在しない」を意味することが多いため、JSONのnullを他のGoの型にアンマーシャルすると、 値には影響せず、エラーも発生しません。

引用符で囲まれた文字列をアンマーシャルするとき、無効なUTF-8または 無効なUTF-16サロゲートペアはエラーとして扱われません。 代わりに、それらはUnicodeの置換文字U+FFFDに置き換えられます。

Example 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/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)
}

Output:

[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

func Valid added in v1.9.0 

func Valid(data []byte) bool

Validは、dataが有効なJSONエンコーディングであるかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
)

func main() {
	goodJSON := `{"example": 1}`
	badJSON := `{"example":2:]}}`

	fmt.Println(json.Valid([]byte(goodJSON)), json.Valid([]byte(badJSON)))
}

Output:

true false

Types

type Decoder 

type Decoder struct {
	// contains filtered or unexported fields
}

Decoderは、入力ストリームからJSON値を読み取り、デコードします。

Example

この例では、Decoderを使用して一連の異なるJSON値をデコードします。 

package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)
	}
}

Output:

Ed: Knock knock.
Sam: Who's there?
Ed: Go fmt.
Sam: Go fmt who?
Ed: Go fmt yourself!

func NewDecoder 

func NewDecoder(r io.Reader) *Decoder

NewDecoderは、rから読み取る新しいデコーダを返します。

デコーダは自身のバッファリングを導入し、 要求されたJSON値を超えてrからデータを読み取る可能性があります。

func (*Decoder) Buffered added in v1.1.0 

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

Bufferedは、Decoderのバッファに残っているデータのリーダーを返します。 リーダーは次のDecode呼び出しまで有効です。

func (*Decoder) Decode 

func (dec *Decoder) Decode(v any) error

Decodeは、入力から次のJSONエンコードされた値を読み取り、 それをvが指す値に格納します。

JSONをGoの値に変換する詳細については、Unmarshalのドキュメンテーションを参照してください。

Example (Stream)

この例では、Decoderを使用してJSONオブジェクトのストリーミング配列をデコードします。 

package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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)

}

Output:

json.Delim: [
Ed: Knock knock.
Sam: Who's there?
Ed: Go fmt.
Sam: Go fmt who?
Ed: Go fmt yourself!
json.Delim: ]

func (*Decoder) DisallowUnknownFields added in v1.10.0 

func (dec *Decoder) DisallowUnknownFields()

DisallowUnknownFieldsは、デコーダに、宛先が構造体であり、入力に宛先の いずれの非無視、エクスポートされたフィールドとも一致しないオブジェクトキーが含まれている場合に エラーを返すよう指示します。

func (*Decoder) InputOffset added in v1.14.0 

func (dec *Decoder) InputOffset() int64

InputOffsetは、現在のデコーダ位置の入力ストリームバイトオフセットを返します。 オフセットは、最近返されたトークンの終わりと次のトークンの始まりの位置を示します。

func (*Decoder) More added in v1.5.0 

func (dec *Decoder) More() bool

Moreは、解析中の現在の配列またはオブジェクトに別の要素があるかどうかを報告します。

func (*Decoder) Token added in v1.5.0 

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

Tokenは、入力ストリームの次のJSONトークンを返します。 入力ストリームの終わりでは、Tokenはnil, io.EOFを返します。

Tokenは、返す区切り文字[ ] { }が適切にネストされ、 マッチしていることを保証します：もしTokenが入力で予期しない 区切り文字に遭遇した場合、エラーを返します。

入力ストリームは、基本的なJSON値—bool, string, number, null—と、配列とオブジェクトの開始と終了を マークするための区切り文字[ ] { }のタイプDelimで構成されています。 コンマとコロンは省略されます。

Example

この例では、Decoderを使用して一連の異なるJSON値をデコードします。 

package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/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")
	}
}

Output:

json.Delim: { (more)
string: Message (more)
string: Hello (more)
string: Array (more)
json.Delim: [ (more)
float64: 1 (more)
float64: 2 (more)
float64: 3
json.Delim: ] (more)
string: Null (more)
<nil>: <nil> (more)
string: Number (more)
float64: 1.234
json.Delim: }

func (*Decoder) UseNumber added in v1.1.0 

func (dec *Decoder) UseNumber()

UseNumberは、Decoderに数値をfloat64ではなく、 Numberとしてinterface{}にアンマーシャルするよう指示します。

type Delim added in v1.5.0 

type Delim rune

Delimは、JSON配列またはオブジェクトの区切り文字であり、[ ] { }のいずれかです。

func (Delim) String added in v1.5.0 

func (d Delim) String() string

type Encoder 

type Encoder struct {
	// contains filtered or unexported fields
}

Encoderは、JSON値を出力ストリームに書き込みます。

func NewEncoder 

func NewEncoder(w io.Writer) *Encoder

NewEncoderは、wに書き込む新しいエンコーダを返します。

func (*Encoder) Encode 

func (enc *Encoder) Encode(v any) error

Encodeは、vのJSONエンコーディングをストリームに書き込み、 その後に改行文字を追加します。

Goの値をJSONに変換する詳細については、Marshalのドキュメンテーションを参照してください。

func (*Encoder) SetEscapeHTML added in v1.7.0 

func (enc *Encoder) SetEscapeHTML(on bool)

SetEscapeHTMLは、問題のあるHTML文字がJSONの引用符で囲まれた文字列内でエスケープされるべきかどうかを指定します。 デフォルトの動作は、&, <, >を\u0026, \u003c, \u003eにエスケープして、 JSONをHTMLに埋め込む際に生じる可能性のある特定の安全性問題を回避します。

エスケープが出力の可読性を妨げる非HTML設定では、SetEscapeHTML(false)でこの動作を無効にします。

func (*Encoder) SetIndent added in v1.7.0 

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

SetIndentは、エンコーダに対して、次にエンコードされる各値を、パッケージレベルの関数Indent(dst, src, prefix, indent)で インデントされているかのようにフォーマットするよう指示します。 SetIndent("", "")を呼び出すと、インデントが無効になります。

type InvalidUTF8Error deprecated 

type InvalidUTF8Error struct {
	S string
}

Go 1.2より前では、InvalidUTF8Errorは、無効なUTF-8シーケンスを含む文字列値をエンコードしようとしたときに Marshalによって返されました。Go 1.2以降では、Marshalは代わりに無効なバイトをUnicodeの置換ルーンU+FFFDで 置き換えることにより、文字列を有効なUTF-8に強制します。

Deprecated: もう使用されていません。互換性のために保持されています。

func (*InvalidUTF8Error) Error 

func (e *InvalidUTF8Error) Error() string

type InvalidUnmarshalError 

type InvalidUnmarshalError struct {
	Type reflect.Type
}

InvalidUnmarshalErrorは、Unmarshalに渡された無効な引数を説明します。 (Unmarshalへの引数はnilでないポインタでなければなりません。)

func (*InvalidUnmarshalError) Error 

func (e *InvalidUnmarshalError) Error() string

type Marshaler 

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

Marshalerは、自身を有効なJSONにマーシャルできる型が実装するインターフェースです。

type MarshalerError 

type MarshalerError struct {
	Type reflect.Type
	Err  error
	// contains filtered or unexported fields
}

MarshalerErrorは、MarshalJSONまたはMarshalTextメソッドを呼び出す際のエラーを表します。

func (*MarshalerError) Error 

func (e *MarshalerError) Error() string

func (*MarshalerError) Unwrap added in v1.13.0 

func (e *MarshalerError) Unwrap() error

Unwrapは基礎となるエラーを返します。

type Number added in v1.1.0 

type Number string

Numberは、JSONの数値リテラルを表します。

func (Number) Float64 added in v1.1.0 

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

Float64は、数値をfloat64として返します。

func (Number) Int64 added in v1.1.0 

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

Int64は、数値をint64として返します。

func (Number) String added in v1.1.0 

func (n Number) String() string

Stringは、数値のリテラルテキストを返します。

type RawMessage 

type RawMessage []byte

RawMessageは、生のエンコードされたJSON値です。 これはMarshalerとUnmarshalerを実装しており、 JSONのデコードを遅延させるか、JSONのエンコードを事前に計算するために使用できます。

Example (Marshal)

この例では、RawMessageを使用して、マーシャル中に事前に計算されたJSONを使用します。 

package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/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)

}

Output:

{
	"header": {
		"precomputed": true
	},
	"body": "Hello Gophers!"
}
Example (Unmarshal)

この例では、RawMessageを使用してJSONメッセージの一部の解析を遅延させます。 

package main

import (
	"github.com/shogo82148/std/encoding/json"
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
)

func main() {
	type Color struct {
		Space string
		Point json.RawMessage // カラースペースがわかるまでの解析を遅延させます
	}
	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 any
		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)
	}
}

Output:

YCbCr &{255 0 -10}
RGB &{98 218 255}

func (RawMessage) MarshalJSON 

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

MarshalJSONは、mのJSONエンコーディングとしてmを返します。

func (*RawMessage) UnmarshalJSON 

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

UnmarshalJSONは、*mをdataのコピーに設定します。

type SyntaxError 

type SyntaxError struct {
	Offset int64
	// contains filtered or unexported fields
}

SyntaxErrorは、JSON構文エラーの説明です。 JSONを解析できない場合、UnmarshalはSyntaxErrorを返します。

func (*SyntaxError) Error 

func (e *SyntaxError) Error() string

type Token added in v1.5.0 

type Token any

Tokenは、以下の型のいずれかの値を保持します: 

Delim、JSONの4つの区切り文字 [ ] { } のため
bool、JSONのブール値のため
float64、JSONの数値のため
Number、JSONの数値のため
string、JSONの文字列リテラルのため
nil、JSONのnullのため

type UnmarshalFieldError deprecated 

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

UnmarshalFieldErrorは、JSONオブジェクトキーが エクスポートされていない（したがって書き込み不可能な）構造体フィールドにつながることを説明します。

Deprecated: もはや使用されていません。互換性のために保持されています。

func (*UnmarshalFieldError) Error 

func (e *UnmarshalFieldError) Error() string

type UnmarshalTypeError 

type UnmarshalTypeError struct {
	Value  string
	Type   reflect.Type
	Offset int64
	Struct string
	Field  string
}

UnmarshalTypeErrorは、特定のGo型の値に対して適切でないJSON値を説明します。

func (*UnmarshalTypeError) Error 

func (e *UnmarshalTypeError) Error() string

type Unmarshaler 

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

Unmarshalerは、自分自身のJSON記述をアンマーシャルできる型によって実装されるインターフェースです。 入力は、JSON値の有効なエンコーディングであると想定できます。 UnmarshalJSONは、戻り値後にデータを保持したい場合、JSONデータをコピーする必要があります。

慣習的に、Unmarshal自体の振る舞いを近似するために、 UnmarshalersはUnmarshalJSON([]byte("null"))を何もしない操作として実装します。

type UnsupportedTypeError 

type UnsupportedTypeError struct {
	Type reflect.Type
}

UnsupportedTypeErrorは、サポートされていない値の型をエンコードしようとしたときに Marshalによって返されます。

func (*UnsupportedTypeError) Error 

func (e *UnsupportedTypeError) Error() string

type UnsupportedValueError 

type UnsupportedValueError struct {
	Value reflect.Value
	Str   string
}

UnsupportedValueErrorは、サポートされていない値をエンコードしようとしたときに Marshalによって返されます。

func (*UnsupportedValueError) Error 

func (e *UnsupportedValueError) Error() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.