json

package
v1.25.0 Latest Latest
Warning

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

 Go to latest Published: Oct 5, 2025 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

Security Considerations

JSON標準（RFC 7159）は、多くのパーサーの動作の定義が曖昧です。 そのため、多くのJSONパーサーは様々なシナリオで異なる動作をします。 パーサーのこれらの違いは、複数の独立したJSONパーサー実装を使用するシステムが 同じJSONオブジェクトを異なる方法で解析する可能性があることを意味します。

セキュリティ目的でJSONオブジェクトが一貫して解析されることに依存するシステムは、 このパーサーの動作と、これらの動作が他のパーサー実装との相互運用性の問題を 引き起こす可能性について注意深く理解する必要があります。

Go後方互換性の約束（https://go.dev/doc/go1compat）により、 このパッケージが示す動作の中には相互運用性の問題を引き起こす可能性があるものが 数多くありますが、変更することはできません。特に以下の解析動作が問題を引き起こす可能性があります：

  • JSONオブジェクトに重複したキーが含まれている場合、キーは観察された順序で処理され、 フィールドタイプに応じて、後の値が以前の値を置き換えるかマージされることを意味します （特にマップと構造体では値がマージされ、その他のタイプでは値が置き換えられます）。
  • JSONオブジェクトをGo構造体に解析する場合、キーは大文字小文字を区別しない方法で考慮されます。
  • JSONオブジェクトをGo構造体に解析する場合、JSONオブジェクト内の未知のキーは無視されます （Decoder が使用されて Decoder.DisallowUnknownFields が呼び出されている場合を除く）。
  • JSON文字列内の無効なUTF-8バイトは、Unicode置換文字に置き換えられます。
  • 大きなJSON数値整数は、浮動小数点型にアンマーシャルされる際に精度を失います。
Example (CustomMarshalJSON) 
//go:build !goexperiment.jsonv2

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) 
//go:build !goexperiment.jsonv2

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は [Marshaler.MarshalJSON] を呼び出して JSONを生成します。[Marshaler.MarshalJSON] メソッドが存在しないが、 その値が代わりに encoding.TextMarshaler を実装している場合、Marshalは encoding.TextMarshaler.MarshalText を呼び出し、その結果をJSON文字列としてエンコードします。 nilポインタの例外は厳密には必要ではありませんが、 [Unmarshaler.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" にエスケープされます。 この置換は、Encoder を使用している場合、Encoder.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:"-,"`

"omitzero"オプションは、フィールドがゼロ値を持つ場合に エンコーディングからフィールドを省略することを指定します。以下のルールに従います：

1) フィールドの型が"IsZero() bool"メソッドを持つ場合、それを使用して 値がゼロかどうかを判定します。

2) それ以外の場合、値がその型のゼロ値であればゼロです。

"omitempty"と"omitzero"の両方が指定された場合、フィールドは 値が空またはゼロ（または両方）の場合に省略されます。

"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はその値の [Unmarshaler.UnmarshalJSON] メソッドを呼び出します、 入力がJSON nullである場合も含みます。 それ以外の場合、もし値が encoding.TextUnmarshaler を実装していて、 入力がJSONの引用符で囲まれた文字列である場合、Unmarshalはその値の encoding.TextUnmarshaler.UnmarshalText を引用符で囲まれていない形式の文字列で呼び出します。

JSONを構造体にアンマーシャルするために、Unmarshalは受信するオブジェクトキーを [Marshal]が使用するキー（構造体フィールド名またはそのタグ）にマッチさせ、 大文字小文字を無視します。複数の構造体フィールドがオブジェクトキーにマッチする場合、 大文字小文字を区別しないマッチよりも正確な大文字小文字マッチが優先されます。

受信するオブジェクトメンバーは、観察された順序で処理されます。オブジェクトに 重複したキーが含まれている場合、後の重複は以前の値を置き換えるか、マージされます。

インターフェース値に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オブジェクトから キーと値のペアをマップに格納します。マップのキーの型は、任意の文字列型、整数、 または 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のバッファに残っているデータのリーダーを返します。 リーダーは次の 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を使用すると、デコーダーは数値を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は、[Marshaler.MarshalJSON] または encoding.TextMarshaler.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データをコピーしなければなりません。

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.