型定義

json パッケージは JSON 操作結果を処理するための複数のタイプセーフな型を提供します。

Result[T] - 統一結果型

Result[T] はジェネリック操作結果型で、タイプセーフなエラー処理と値アクセスを提供します。

構造定義

type Result[T any] struct {
    Value  T     // 結果値
    Exists bool  // 値が見つかったか
    Error  error // エラー（ある場合）
}

メソッド

メソッド	シグネチャ	説明
`Ok()`	`func (r Result[T]) Ok() bool`	結果が有効かチェック（エラーなし、かつ見つかっている）
`Unwrap()`	`func (r Result[T]) Unwrap() T`	値を返す、失敗時はゼロ値を返す
`UnwrapOr()`	`func (r Result[T]) UnwrapOr(defaultValue T) T`	値またはデフォルト値を返す

使用例

package main

import (
    "fmt"
    "github.com/cybergodev/json"
)

func main() {
    data := `{"user": {"name": "Alice", "age": 30}}`

    // GetTyped で型付き値を取得
    name := json.GetTyped[string](data, "user.name")
    fmt.Printf("名前: %s\n", name)

    // defaultValue パラメータでデフォルト値を指定
    nickname := json.GetTyped[string](data, "user.nickname", "未設定")
    fmt.Printf("ニックネーム: %s\n", nickname)

    age := json.GetTyped[int](data, "user.age", 0)
    fmt.Printf("年齢：%d\n", age)
}

命名規約

GetTyped[T] - 指定型の値を取得、T を返す、defaultValue パラメータ対応
Result[T] - 内部結果型、詳細なエラー処理が必要な場面で使用

CompiledPath - プリコンパイル済みパス

CompiledPath はプリコンパイル済みの JSON パス型エイリアスで、同じパスに頻繁にアクセスする際のパス文字列の再解析を回避し、パフォーマンスを向上させます。

型定義

type CompiledPath = internal.CompiledPath

ユースケース

同じパスに対して大量の繰り返し操作が必要な場合（ループ内での一括クエリなど）、パスを事前にコンパイルすることで、毎回のパス文字列解析のオーバーヘッドを削減できます。

コンパイル関数

Processor.CompilePath

シグネチャ：func (p *Processor) CompilePath(path string) (*CompiledPath, error)

Processor を通じて JSON パスをプリコンパイルし、後続の操作で再利用可能な *CompiledPath インスタンスを返します。

processor, err := json.New()
if err != nil {
    panic(err)
}
defer processor.Close()

compiled, err := processor.CompilePath("user.profile.name")
if err != nil {
    panic(err)
}
// 後続の操作で compiled を再利用可能
val, err := processor.GetCompiled(data, compiled)

パフォーマンスのヒント

高頻度の繰り返しパスアクセスでは、パスのプリコンパイルによりパス解析のオーバーヘッドを大幅に削減できます。一括操作やループ内クエリなどのシナリオに適しています。

AccessResult - プロパティアクセス結果

AccessResult は安全なプロパティアクセス結果で、メソッドチェーンによる型変換を提供します。

構造定義

type AccessResult struct {
    Value  any    // 結果値
    Exists bool   // パスが存在するか
    Type   string // 実行時型情報（デバッグ用）
}

作成メソッド

Processor.SafeGet

シグネチャ：func (p *Processor) SafeGet(jsonStr, path string, cfg ...Config) AccessResult

安全にプロパティを取得し、チェーン型変換用の AccessResult を返します。

パッケージレベル関数 SafeGet も使用可能です：

シグネチャ：func SafeGet(jsonStr, path string, cfg ...Config) AccessResult

processor, err := json.New()
if err != nil {
    panic(err)
}
defer processor.Close()

result := processor.SafeGet(data, "user.age")

if !result.Exists {
    fmt.Println("パスが存在しません")
    return
}

// 型の確認
fmt.Println("型：", result.Type)

チェーン型変換メソッド

メソッド	戻り値の型	説明
`Unwrap()`	`any`	値を返す、存在しない場合は nil を返す
`UnwrapOr(defaultValue)`	`any`	値またはデフォルト値を返す
`AsString()`	`(string, error)`	文字列に変換（厳格な型チェック）
`AsStringConverted()`	`(string, error)`	フォーマット変換で文字列に変換
`AsInt()`	`(int, error)`	整数に変換（bool は変換しない）
`AsFloat64()`	`(float64, error)`	float64 に変換（bool は変換しない）
`AsBool()`	`(bool, error)`	ブーリアンに変換
`Ok()`	`bool`	値が存在するか確認（`Exists` を返す）

注意

AsInt64(), AsArray(), AsObject() メソッドは削除されました。これらの型を取得するには GetTyped[T] を使用してください。

result := processor.SafeGet(data, "user.profile")

// チェーン呼び出し
name, _ := result.AsString()
email, _ := result.AsString()
age, _ := result.AsInt()
price, _ := result.AsFloat64()
active, _ := result.AsBool()

// 配列やオブジェクト型が必要な場合は GetTyped を使用
arr := json.GetTyped[[]any](data, "items")
obj := json.GetTyped[map[string]any](data, "user.profile")

使用例

package main

import (
    "fmt"
    "github.com/cybergodev/json"
)

func main() {
    processor, err := json.New()
    if err != nil {
        panic(err)
    }
    defer processor.Close()

    data := `{"user": {"name": "Alice", "age": 30, "active": true}}`

    // 安全に取得して変換
    result := processor.SafeGet(data, "user.age")

    // AccessResult メソッドを直接使用
    age, err := result.AsInt()
    if err != nil {
        panic(err)
    }
    fmt.Printf("年齢：%d\n", age)

    // 存在しないパスの取得
    missing := processor.SafeGet(data, "user.nickname")
    if !missing.Exists {
        fmt.Println("ニックネームは存在しません")
    }
}

Schema - JSON Schema 型

Schema は JSON データの構造バリデーションルールを定義するために使用し、JSON Schema Draft 7 のサブセットをサポートします。

構造定義

type Schema struct {
    Type                 string            `json:"type,omitempty"`
    Properties           map[string]*Schema `json:"properties,omitempty"`
    Items                *Schema           `json:"items,omitempty"`
    Required             []string          `json:"required,omitempty"`
    MinLength            int               `json:"minLength,omitempty"`
    MaxLength            int               `json:"maxLength,omitempty"`
    Minimum              float64           `json:"minimum,omitempty"`
    Maximum              float64           `json:"maximum,omitempty"`
    Pattern              string            `json:"pattern,omitempty"`
    Format               string            `json:"format,omitempty"`
    AdditionalProperties bool              `json:"additionalProperties,omitempty"`
    MinItems             int               `json:"minItems,omitempty"`
    MaxItems             int               `json:"maxItems,omitempty"`
    UniqueItems          bool              `json:"uniqueItems,omitempty"`
    Enum                 []any             `json:"enum,omitempty"`
    Const                any               `json:"const,omitempty"`
    MultipleOf           float64           `json:"multipleOf,omitempty"`
    ExclusiveMinimum     bool              `json:"exclusiveMinimum,omitempty"`
    ExclusiveMaximum     bool              `json:"exclusiveMaximum,omitempty"`
    Title                string            `json:"title,omitempty"`
    Description          string            `json:"description,omitempty"`
    Default              any               `json:"default,omitempty"`
    Examples             []any             `json:"examples,omitempty"`
}

Schema の作成

直接構築

schema := &json.Schema{
    Type:     "object",
    Required: []string{"name", "email"},
    Properties: map[string]*json.Schema{
        "name":  {Type: "string", MinLength: 1},
        "email": {Type: "string", Format: "email"},
        "age":   {Type: "integer", Minimum: 0},
    },
}

NewSchemaWithConfig の使用

cfg := json.DefaultSchemaConfig()
cfg.Type = "object"
cfg.Required = []string{"name", "email"}
schema := json.NewSchemaWithConfig(cfg)

DefaultSchema の使用

シグネチャ：func DefaultSchema() *Schema

デフォルト設定を含む空の Schema インスタンスを返します。

schema := json.DefaultSchema()
schema.Type = "object"
schema.Required = []string{"id"}

SchemaConfig 構造体

type SchemaConfig struct {
    Type                 string
    Properties           map[string]*Schema
    Items                *Schema
    Required             []string
    MinLength            *int
    MaxLength            *int
    Minimum              *float64
    Maximum              *float64
    Pattern              string
    Format               string
    AdditionalProperties *bool
    MinItems             *int
    MaxItems             *int
    UniqueItems          bool
    Enum                 []any
    Const                any
    MultipleOf           *float64
    ExclusiveMinimum     *bool
    ExclusiveMaximum     *bool
    Title                string
    Description          string
    Default              any
    Examples             []any
}

使用例

package main

import (
    "fmt"
    "github.com/cybergodev/json"
)

func main() {
    // 構造体リテラルで Schema を定義
    schema := &json.Schema{
        Type:     "object",
        Required: []string{"name", "email"},
        Properties: map[string]*json.Schema{
            "name": {
                Type:      "string",
                MinLength: 1,
                MaxLength: 100,
            },
            "email": {
                Type:   "string",
                Format: "email",
            },
            "age": {
                Type:    "integer",
                Minimum: 0,
                Maximum: 150,
            },
        },
        AdditionalProperties: false,
    }

    // JSON のバリデーション
    data := `{"name": "Alice", "email": "[email protected]", "age": 30}`
    errors, err := json.ValidateSchema(data, schema)
    if err != nil {
        panic(err)
    }

    if len(errors) > 0 {
        for _, e := range errors {
            fmt.Printf("バリデーションエラー [%s]: %s\n", e.Path, e.Message)
        }
    } else {
        fmt.Println("バリデーション成功")
    }
}

ValidationError

Schema バリデーションエラー型。

構造定義

type ValidationError struct {
    Path    string `json:"path"`    // エラーが発生したパス
    Message string `json:"message"` // エラーメッセージ
}

メソッド

Error

シグネチャ：func (ve *ValidationError) Error() string

error インターフェースを実装します。

for _, e := range errors {
    fmt.Println(e.Error())
}

BatchOperation

一括操作の定義。

構造定義

type BatchOperation struct {
    Type    string `json:"type"`     // 操作タイプ："get", "set", "delete", "validate"
    JSONStr string `json:"json_str"` // JSON データ文字列
    Path    string `json:"path"`     // 対象パス
    Value   any    `json:"value"`    // Set 操作の値
    ID      string `json:"id"`       // 操作識別子
}

BatchResult

一括操作の結果。

構造定義

type BatchResult struct {
    ID     string `json:"id"`     // 操作識別子（BatchOperation.ID に対応）
    Result any    `json:"result"` // 操作結果
    Error  error  `json:"error"`  // エラー（ある場合）
}

WarmupResult

キャッシュウォームアップ結果。

構造定義

type WarmupResult struct {
    TotalPaths  int      `json:"total_paths"`            // 合計パス数
    Successful  int      `json:"successful"`             // ウォームアップ成功数
    Failed      int      `json:"failed"`                 // 失敗数
    SuccessRate float64  `json:"success_rate"`           // 成功率
    FailedPaths []string `json:"failed_paths,omitempty"` // 失敗パスリスト
}

ParsedJSON

事前パース済みの JSON ドキュメント。複数回のクエリ操作で再利用可能です。

構造定義

ParsedJSON の内部フィールドは非公開で、メソッドを通じてアクセスします。

type ParsedJSON struct {
    // 内部フィールド（非公開）
    // Data() メソッドでパース済みデータを取得
}

Data メソッド

シグネチャ：func (p *ParsedJSON) Data() any

内部のパース済みデータを返します。

Release メソッド

シグネチャ：func (p *ParsedJSON) Release()

パース済みデータが保持しているリソースを解放します。ParsedJSON が不要になった時に呼び出し、内部リソースのガベージコレクションを許可します。

processor, err := json.New()
if err != nil {
    panic(err)
}
defer processor.Close()

// JSON の事前パース
parsed, err := processor.PreParse(`{"user": {"name": "Alice", "age": 30}}`)
if err != nil {
    panic(err)
}

// 事前パース結果に対する複数回のクエリ
name, _ := processor.GetFromParsed(parsed, "user.name")
age, _ := processor.GetFromParsed(parsed, "user.age")

ユースケース

シナリオ	説明
高頻度クエリ	同一 JSON の複数回クエリで再パースを回避
一括パス取得	`GetMultiple` で複数パスを一括取得
パフォーマンス最適化	事前パース後のクエリパフォーマンスが大幅に向上

パフォーマンスのヒント

同じ JSON 文字列に対して複数回クエリする必要がある場面では、PreParse による事前パースで再パースのオーバーヘッドを大幅に削減できます。

Stats

プロセッサの統計情報。

構造定義

type Stats struct {
    CacheSize        int64         `json:"cache_size"`        // 現在のキャッシュサイズ
    CacheMemory      int64         `json:"cache_memory"`      // キャッシュメモリ使用量（バイト）
    MaxCacheSize     int           `json:"max_cache_size"`    // キャッシュ最大サイズ
    HitCount         int64         `json:"hit_count"`         // キャッシュヒット数
    MissCount        int64         `json:"miss_count"`        // キャッシュミス数
    HitRatio         float64       `json:"hit_ratio"`         // キャッシュヒット率
    CacheTTL         time.Duration `json:"cache_ttl"`         // キャッシュ有効期限
    CacheEnabled     bool          `json:"cache_enabled"`     // キャッシュが有効か
    IsClosed         bool          `json:"is_closed"`         // プロセッサがクローズされているか
    MemoryEfficiency float64       `json:"memory_efficiency"` // メモリ効率
    OperationCount   int64         `json:"operation_count"`   // 操作総数
    ErrorCount       int64         `json:"error_count"`       // エラー総数
}

HealthStatus

ヘルスステータス情報。

構造定義

type HealthStatus struct {
    Timestamp time.Time              `json:"timestamp"` // チェックのタイムスタンプ
    Healthy   bool                   `json:"healthy"`   // 健康かどうか
    Checks    map[string]CheckResult `json:"checks"`    // 各チェック項目の結果
}

CheckResult 構造体

type CheckResult struct {
    Healthy bool   `json:"healthy"` // このチェック項目が健康か
    Message string `json:"message"` // チェックメッセージ
}

IterableValue

反復値のラッパー。

メソッド概要

基本アクセス

メソッド	説明
`Get(path)`	パスで値を取得
`GetString(path)`	文字列を取得
`GetInt(path)`	整数を取得
`GetFloat64(path)`	浮動小数点数を取得
`GetBool(path)`	ブーリアンを取得
`GetArray(path)`	配列を取得
`GetObject(path)`	オブジェクトを取得

デフォルト値付き取得

メソッド	説明
`GetWithDefault(path, defaultValue)`	値を取得、存在しない場合はデフォルト値を返す
`GetStringWithDefault(path, defaultValue)`	文字列を取得、存在しない場合はデフォルト値を返す
`GetIntWithDefault(path, defaultValue)`	整数を取得、存在しない場合はデフォルト値を返す
`GetFloat64WithDefault(path, defaultValue)`	浮動小数点数を取得、存在しない場合はデフォルト値を返す
`GetBoolWithDefault(path, defaultValue)`	ブーリアンを取得、存在しない場合はデフォルト値を返す

チェックと走査

メソッド	説明
`Exists(path)`	フィールドが存在するかチェック
`IsNull(path)`	指定パスが null かチェック
`IsNullData()`	内部値が null かチェック
`IsEmpty(path)`	指定パスが空かチェック
`IsEmptyData()`	内部値が空かチェック
`GetData()`	内部の生データを取得
`Break()`	中断シグナルを返し、イテレーションを停止
`ForeachNested(path, fn)`	ネストされた構造を再帰的に走査
`Release()`	リソースを解放

詳細はイテレータドキュメントを参照してください。

エンコードエラー型

json パッケージはエンコード/デコードプロセス中の以下のエラー型をエクスポートし、きめ細かなエラー処理に使用します。

SyntaxError - 構文エラー

JSON 構文解析エラー。入力データが有効な JSON 形式ではないことを示します。

構造定義

type SyntaxError struct {
    Offset int64 // エラー発生位置（バイトオフセット）
    // その他の非公開フィールドを含む
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *SyntaxError) Error() string`	オフセット位置を含むエラー説明を返す

data := `{invalid json}`
_, err := json.ParseAny(data)
if syntaxErr, ok := err.(*json.SyntaxError); ok {
    fmt.Printf("構文エラー、オフセット：%d\n", syntaxErr.Offset)
}

UnmarshalTypeError - デシリアライズ型エラー

JSON 値をターゲットの Go 型に変換できない場合にこのエラーが返されます。

構造定義

type UnmarshalTypeError struct {
    Value  string       // JSON 値の説明（例："string", "number"）
    Type   reflect.Type // ターゲットの Go 型
    Offset int64        // エラー発生位置（バイトオフセット）
    Struct string       // このフィールドを含む構造体名（ある場合）
    Field  string       // フィールド名（ある場合）
    Err    error        // 内部エラー（ある場合）
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *UnmarshalTypeError) Error() string`	型不一致のエラー説明を返す
`Unwrap`	`func (e *UnmarshalTypeError) Unwrap() error`	内部エラーを返す

type User struct {
    Age int `json:"age"`
}
var user User
err := json.Unmarshal([]byte(`{"age": "not_a_number"}`), &user)
if typeErr, ok := err.(*json.UnmarshalTypeError); ok {
    fmt.Printf("型エラー: JSON 値 %s を %v に変換できません\n", typeErr.Value, typeErr.Type)
}

UnsupportedTypeError - サポートされていない型エラー

Go でサポートされていない型をエンコードしようとした場合にこのエラーが返されます。

構造定義

type UnsupportedTypeError struct {
    Type reflect.Type // サポートされていない Go 型
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *UnsupportedTypeError) Error() string`	サポートされていない型の説明を返す

type Chan chan int
data := Chan(make(chan int))
_, err := json.Marshal(data)
if unsupportedErr, ok := err.(*json.UnsupportedTypeError); ok {
    fmt.Printf("サポートされていない型: %v\n", unsupportedErr.Type)
}

UnsupportedValueError - サポートされていない値エラー

サポートされていない値（NaN、Infinity など）をエンコードしようとした場合にこのエラーが返されます。

構造定義

type UnsupportedValueError struct {
    Value reflect.Value // サポートされていない値
    Str   string        // エラー説明
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *UnsupportedValueError) Error() string`	サポートされていない値の説明を返す

val := math.NaN()
_, err := json.Marshal(val)
if valErr, ok := err.(*json.UnsupportedValueError); ok {
    fmt.Printf("サポートされていない値: %s\n", valErr.Str)
}

InvalidUnmarshalError - 無効なデシリアライズ先エラー

Unmarshal のターゲット引数がポインタでない、または nil の場合にこのエラーが返されます。

構造定義

type InvalidUnmarshalError struct {
    Type reflect.Type // ターゲット引数の型
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *InvalidUnmarshalError) Error() string`	無効なターゲットのエラー説明を返す

var target string // ポインタを渡すべき
err := json.Unmarshal([]byte(`"hello"`), target) // エラー：ポインタが渡されていない
if invalidErr, ok := err.(*json.InvalidUnmarshalError); ok {
    fmt.Printf("無効なデシリアライズ先: %v\n", invalidErr.Type)
}

MarshalerError - エンコーダエラー

型の MarshalJSON または MarshalText メソッドがエラーを返した場合にこのエラーでラップされます。

構造定義

type MarshalerError struct {
    Type reflect.Type // MarshalJSON または MarshalText を実装する型
    Err  error        // MarshalJSON または MarshalText が返したエラー
    // その他の非公開フィールドを含む
}

メソッド

メソッド	シグネチャ	説明
`Error`	`func (e *MarshalerError) Error() string`	エンコーダエラーの説明を返す
`Unwrap`	`func (e *MarshalerError) Unwrap() error`	内部エラーを返す

type BadMarshaler struct{}

func (BadMarshaler) MarshalJSON() ([]byte, error) {
    return nil, errors.New("marshal failed")
}

_, err := json.Marshal(BadMarshaler{})
if marshalErr, ok := err.(*json.MarshalerError); ok {
    fmt.Printf("エンコーダエラー (型: %v): %v\n", marshalErr.Type, marshalErr.Err)
}

Encoder - JSON エンコーダ

Encoder は JSON 値を出力ストリームに書き込みます。encoding/json.Encoder と 100% 互換です。

作成

シグネチャ：func NewEncoder(w io.Writer, cfg ...Config) *Encoder

w に書き込むエンコーダを作成します。オプションの Config パラメータでエンコード動作をカスタマイズできます。

file, _ := os.Create("output.json")
defer file.Close()

encoder := json.NewEncoder(file)
err := encoder.Encode(map[string]any{"name": "Alice"})

メソッド

メソッド	シグネチャ	説明
`Encode`	`func (enc *Encoder) Encode(v any) error`	Go 値を JSON にエンコードしてストリームに書き込む
`SetEscapeHTML`	`func (enc *Encoder) SetEscapeHTML(on bool)`	HTML 特殊文字のエスケープ設定
`SetIndent`	`func (enc *Encoder) SetIndent(prefix, indent string)`	インデントフォーマットの設定

使用例

package main

import (
    "bytes"
    "fmt"
    "github.com/cybergodev/json"
)

func main() {
    var buf bytes.Buffer
    encoder := json.NewEncoder(&buf)
    encoder.SetIndent("", "  ")
    encoder.SetEscapeHTML(true)

    err := encoder.Encode(map[string]any{
        "name":  "Alice",
        "email": "[email protected]",
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(buf.String())
}

Decoder - JSON デコーダ

Decoder は入力ストリームから JSON 値を読み取ってデコードします。encoding/json.Decoder と 100% 互換です。

作成

シグネチャ：func NewDecoder(r io.Reader, cfg ...Config) *Decoder

r から読み取るデコーダを作成します。オプションの Config パラメータをサポートします。

file, _ := os.Open("data.json")
defer file.Close()

decoder := json.NewDecoder(file)
for decoder.More() {
    var obj map[string]any
    if err := decoder.Decode(&obj); err != nil {
        break
    }
    fmt.Println(obj)
}

メソッド

メソッド	シグネチャ	説明
`Decode`	`func (dec *Decoder) Decode(v any) error`	ストリームから次の JSON 値を読み取ってデコード
`UseNumber`	`func (dec *Decoder) UseNumber()`	デコーダが数値を `float64` ではなく `Number` として解析するように設定
`DisallowUnknownFields`	`func (dec *Decoder) DisallowUnknownFields()`	デコード時に未知フィールドがあるとエラーを返す
`Buffered`	`func (dec *Decoder) Buffered() io.Reader`	デコーダのバッファに残っているデータの Reader を返す
`InputOffset`	`func (dec *Decoder) InputOffset() int64`	現在の入力位置のオフセットを返す
`More`	`func (dec *Decoder) More() bool`	ストリームにまだ JSON 値があるかチェック
`Token`	`func (dec *Decoder) Token() (Token, error)`	次の JSON トークンを読み取る

使用例

package main

import (
    "fmt"
    "strings"
    "github.com/cybergodev/json"
)

func main() {
    input := `{"name":"Alice","age":30}{"name":"Bob","age":25}`
    decoder := json.NewDecoder(strings.NewReader(input))

    for decoder.More() {
        var person map[string]any
        if err := decoder.Decode(&person); err != nil {
            break
        }
        fmt.Printf("名前: %s, 年齢: %v\n", person["name"], person["age"])
    }
}

ストリーミングデコードの例

package main

import (
    "fmt"
    "strings"
    "github.com/cybergodev/json"
)

func main() {
    // JSON ストリーム内の複数の値をデコード
    input := `[1,2,3][4,5,6]`
    decoder := json.NewDecoder(strings.NewReader(input))

    for decoder.More() {
        var arr []any
        if err := decoder.Decode(&arr); err != nil {
            panic(err)
        }
        fmt.Println(arr)
    }
}

トークン読み取りの例

decoder := json.NewDecoder(strings.NewReader(`{"name":"Alice"}`))
for {
    token, err := decoder.Token()
    if err != nil {
        break
    }
    switch v := token.(type) {
    case json.Delim:
        fmt.Printf("デリミタ: %s\n", string(v))
    case string:
        fmt.Printf("文字列: %s\n", v)
    case float64:
        fmt.Printf("数値: %v\n", v)
    case bool:
        fmt.Printf("ブーリアン: %v\n", v)
    case nil:
        fmt.Println("null")
    }
}

Token - JSON トークン

Token は JSON トークン値で、以下のいずれかの型を保持します：

Delim：4 つの JSON デリミタ [ ] { } を表す
bool：JSON ブーリアンを表す
float64：JSON 数値を表す
Number：UseNumber 有効時の JSON 数値を表す
string：JSON 文字列を表す
nil：JSON null を表す

type Token any

Decoder.Token() で取得します。

Number - JSON 数値

Number は JSON 数値文字列を表し、UseNumber モードが有効な場合に Decoder で使用されます。

type Number string

メソッド

メソッド	シグネチャ	説明
`String`	`func (n Number) String() string`	数値の文字列表現を返す
`Float64`	`func (n Number) Float64() (float64, error)`	float64 に変換
`Int64`	`func (n Number) Int64() (int64, error)`	int64 に変換

decoder := json.NewDecoder(strings.NewReader(`{"price": 19.99}`))
decoder.UseNumber()
var obj map[string]any
decoder.Decode(&obj)

if num, ok := obj["price"].(json.Number); ok {
    f, _ := num.Float64()
    fmt.Println(f) // 19.99
}

Delim - JSON デリミタ

Delim は JSON デリミタ型で、[、]、{、} の 4 つの文字に対応します。

type Delim rune

メソッド

String

シグネチャ：func (d Delim) String() string

デリミタの文字列表現を返します。

token, _ := decoder.Token()
if delim, ok := token.(json.Delim); ok {
    fmt.Println(delim.String()) // "[" や "{" など
}

型定義 ​

Result[T] - 統一結果型 ​

構造定義 ​

メソッド ​

使用例 ​

CompiledPath - プリコンパイル済みパス ​

型定義 ​

ユースケース ​

コンパイル関数 ​

Processor.CompilePath ​

AccessResult - プロパティアクセス結果 ​

構造定義 ​

作成メソッド ​

Processor.SafeGet ​

チェーン型変換メソッド ​

使用例 ​

Schema - JSON Schema 型 ​

構造定義 ​

Schema の作成 ​

直接構築 ​

NewSchemaWithConfig の使用 ​

DefaultSchema の使用 ​

SchemaConfig 構造体 ​

使用例 ​

ValidationError ​

構造定義 ​

メソッド ​

Error ​

BatchOperation ​

構造定義 ​

BatchResult ​

構造定義 ​

WarmupResult ​

構造定義 ​

ParsedJSON ​

構造定義 ​

Data メソッド ​

Release メソッド ​

ユースケース ​

Stats ​

構造定義 ​

HealthStatus ​

構造定義 ​

CheckResult 構造体 ​

IterableValue ​

メソッド概要 ​

エンコードエラー型 ​

SyntaxError - 構文エラー ​

構造定義 ​

メソッド ​

UnmarshalTypeError - デシリアライズ型エラー ​

構造定義 ​

メソッド ​

UnsupportedTypeError - サポートされていない型エラー ​

構造定義 ​

メソッド ​

UnsupportedValueError - サポートされていない値エラー ​

構造定義 ​

メソッド ​

InvalidUnmarshalError - 無効なデシリアライズ先エラー ​

構造定義 ​

メソッド ​

MarshalerError - エンコーダエラー ​

構造定義 ​

メソッド ​

Encoder - JSON エンコーダ ​

作成 ​

メソッド ​

使用例 ​

Decoder - JSON デコーダ ​

作成 ​

メソッド ​

使用例 ​

ストリーミングデコードの例 ​

トークン読み取りの例 ​

Token - JSON トークン ​

Number - JSON 数値 ​

メソッド ​

Delim - JSON デリミタ ​

メソッド ​

型定義

Result[T] - 統一結果型

構造定義

メソッド

使用例

CompiledPath - プリコンパイル済みパス

型定義

ユースケース

コンパイル関数

Processor.CompilePath

AccessResult - プロパティアクセス結果

構造定義

作成メソッド

Processor.SafeGet

チェーン型変換メソッド

使用例

Schema - JSON Schema 型

構造定義

Schema の作成

直接構築

NewSchemaWithConfig の使用

DefaultSchema の使用

SchemaConfig 構造体

使用例

ValidationError

構造定義

メソッド

Error

BatchOperation

構造定義

BatchResult

構造定義

WarmupResult

構造定義

ParsedJSON

構造定義

Data メソッド

Release メソッド

ユースケース

Stats

構造定義

HealthStatus

構造定義

CheckResult 構造体

IterableValue

メソッド概要

エンコードエラー型

SyntaxError - 構文エラー

構造定義

メソッド

UnmarshalTypeError - デシリアライズ型エラー

構造定義

メソッド

UnsupportedTypeError - サポートされていない型エラー

構造定義

メソッド

UnsupportedValueError - サポートされていない値エラー

構造定義

メソッド

InvalidUnmarshalError - 無効なデシリアライズ先エラー

構造定義

メソッド

MarshalerError - エンコーダエラー

構造定義

メソッド

Encoder - JSON エンコーダ

作成

メソッド

使用例

Decoder - JSON デコーダ

作成

メソッド

使用例

ストリーミングデコードの例

トークン読み取りの例

Token - JSON トークン

Number - JSON 数値

メソッド

Delim - JSON デリミタ

メソッド