README

Sourcegraph GoDoc Build Status codecov rcard License Gitter chat

A high-performance 100% compatible drop-in replacement of "encoding/json"

You can also use thrift like JSON using thrift-iterator

Benchmark

benchmark

Source code: https://github.com/json-iterator/go-benchmark/blob/master/src/github.com/json-iterator/go-benchmark/benchmark_medium_payload_test.go

Raw Result (easyjson requires static code generation)

ns/op allocation bytes allocation times
std decode 35510 ns/op 1960 B/op 99 allocs/op
easyjson decode 8499 ns/op 160 B/op 4 allocs/op
jsoniter decode 5623 ns/op 160 B/op 3 allocs/op
std encode 2213 ns/op 712 B/op 5 allocs/op
easyjson encode 883 ns/op 576 B/op 3 allocs/op
jsoniter encode 837 ns/op 384 B/op 4 allocs/op

Always benchmark with your own workload. The result depends heavily on the data input.

Usage

100% compatibility with standard lib

Replace

import "encoding/json"
json.Marshal(&data)

with

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Marshal(&data)

Replace

import "encoding/json"
json.Unmarshal(input, &data)

with

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Unmarshal(input, &data)

More documentation

How to get

go get github.com/json-iterator/go

Contribution Welcomed !

Contributors

Report issue or pull request, or email taowen@gmail.com, or Gitter chat

Expand ▾ Collapse ▴

Documentation

Overview

    Package jsoniter implements encoding and decoding of JSON as defined in RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json. Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter and variable type declarations (if any). jsoniter interfaces gives 100% compatibility with code using standard lib.

    "JSON and Go" (https://golang.org/doc/articles/json_and_go.html) gives a description of how Marshal/Unmarshal operate between arbitrary or predefined json objects and bytes, and it applies to jsoniter.Marshal/Unmarshal as well.

    Besides, jsoniter.Iterator provides a different set of interfaces iterating given bytes/string/reader and yielding parsed elements one by one. This set of interfaces reads input as required and gives better performance.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    View Source
    var ConfigCompatibleWithStandardLibrary = Config{
    	EscapeHTML:             true,
    	SortMapKeys:            true,
    	ValidateJsonRawMessage: true,
    }.Froze()

      ConfigCompatibleWithStandardLibrary tries to be 100% compatible with standard library behavior

      View Source
      var ConfigDefault = Config{
      	EscapeHTML: true,
      }.Froze()

        ConfigDefault the default API

        View Source
        var ConfigFastest = Config{
        	EscapeHTML:                    false,
        	MarshalFloatWith6Digits:       true,
        	ObjectFieldMustBeSimpleString: true,
        }.Froze()

          ConfigFastest marshals float with only 6 digits precision

          Functions

          func CastJsonNumber

          func CastJsonNumber(val interface{}) (string, bool)

          func Marshal

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

            Marshal adapts to json/encoding Marshal API

            Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API Refer to https://godoc.org/encoding/json#Marshal for more information

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

            func MarshalIndent

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

              MarshalIndent same as json.MarshalIndent. Prefix is not supported.

              func MarshalToString

              func MarshalToString(v interface{}) (string, error)

                MarshalToString convenient method to write as string instead of []byte

                func RegisterExtension

                func RegisterExtension(extension Extension)

                  RegisterExtension register extension

                  func RegisterFieldDecoder

                  func RegisterFieldDecoder(typ string, field string, decoder ValDecoder)

                    RegisterFieldDecoder register TypeDecoder for a struct field

                    func RegisterFieldDecoderFunc

                    func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc)

                      RegisterFieldDecoderFunc register TypeDecoder for a struct field with function

                      func RegisterFieldEncoder

                      func RegisterFieldEncoder(typ string, field string, encoder ValEncoder)

                        RegisterFieldEncoder register TypeEncoder for a struct field

                        func RegisterFieldEncoderFunc

                        func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool)

                          RegisterFieldEncoderFunc register TypeEncoder for a struct field with encode/isEmpty function

                          func RegisterTypeDecoder

                          func RegisterTypeDecoder(typ string, decoder ValDecoder)

                            RegisterTypeDecoder register TypeDecoder for a typ

                            func RegisterTypeDecoderFunc

                            func RegisterTypeDecoderFunc(typ string, fun DecoderFunc)

                              RegisterTypeDecoderFunc register TypeDecoder for a type with function

                              func RegisterTypeEncoder

                              func RegisterTypeEncoder(typ string, encoder ValEncoder)

                                RegisterTypeEncoder register TypeEncoder for a type

                                func RegisterTypeEncoderFunc

                                func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool)

                                  RegisterTypeEncoderFunc register TypeEncoder for a type with encode/isEmpty function

                                  func Unmarshal

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

                                    Unmarshal adapts to json/encoding Unmarshal API

                                    Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v. Refer to https://godoc.org/encoding/json#Unmarshal for more information

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

                                    func UnmarshalFromString

                                    func UnmarshalFromString(str string, v interface{}) error

                                      UnmarshalFromString is a convenient method to read from string instead of []byte

                                      func Valid

                                      func Valid(data []byte) bool

                                        Valid reports whether data is a valid JSON encoding.

                                        Types

                                        type API

                                        type API interface {
                                        	IteratorPool
                                        	StreamPool
                                        	MarshalToString(v interface{}) (string, error)
                                        	Marshal(v interface{}) ([]byte, error)
                                        	MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
                                        	UnmarshalFromString(str string, v interface{}) error
                                        	Unmarshal(data []byte, v interface{}) error
                                        	Get(data []byte, path ...interface{}) Any
                                        	NewEncoder(writer io.Writer) *Encoder
                                        	NewDecoder(reader io.Reader) *Decoder
                                        	Valid(data []byte) bool
                                        	RegisterExtension(extension Extension)
                                        	DecoderOf(typ reflect2.Type) ValDecoder
                                        	EncoderOf(typ reflect2.Type) ValEncoder
                                        }

                                          API the public interface of this package. Primary Marshal and Unmarshal.

                                          type Any

                                          type Any interface {
                                          	LastError() error
                                          	ValueType() ValueType
                                          	MustBeValid() Any
                                          	ToBool() bool
                                          	ToInt() int
                                          	ToInt32() int32
                                          	ToInt64() int64
                                          	ToUint() uint
                                          	ToUint32() uint32
                                          	ToUint64() uint64
                                          	ToFloat32() float32
                                          	ToFloat64() float64
                                          	ToString() string
                                          	ToVal(val interface{})
                                          	Get(path ...interface{}) Any
                                          	Size() int
                                          	Keys() []string
                                          	GetInterface() interface{}
                                          	WriteTo(stream *Stream)
                                          }

                                            Any generic object representation. The lazy json implementation holds []byte and parse lazily.

                                            func Get

                                            func Get(data []byte, path ...interface{}) Any

                                              Get quick method to get value from deeply nested JSON structure

                                              Example
                                              Output:
                                              
                                              Crimson
                                              

                                              func Wrap

                                              func Wrap(val interface{}) Any

                                                Wrap turn a go object into Any interface

                                                func WrapFloat64

                                                func WrapFloat64(val float64) Any

                                                  WrapFloat64 turn float64 into Any interface

                                                  func WrapInt32

                                                  func WrapInt32(val int32) Any

                                                    WrapInt32 turn int32 into Any interface

                                                    func WrapInt64

                                                    func WrapInt64(val int64) Any

                                                      WrapInt64 turn int64 into Any interface

                                                      func WrapString

                                                      func WrapString(val string) Any

                                                        WrapString turn string into Any interface

                                                        func WrapUint32

                                                        func WrapUint32(val uint32) Any

                                                          WrapUint32 turn uint32 into Any interface

                                                          func WrapUint64

                                                          func WrapUint64(val uint64) Any

                                                            WrapUint64 turn uint64 into Any interface

                                                            type Binding

                                                            type Binding struct {
                                                            	Field     reflect2.StructField
                                                            	FromNames []string
                                                            	ToNames   []string
                                                            	Encoder   ValEncoder
                                                            	Decoder   ValDecoder
                                                            	// contains filtered or unexported fields
                                                            }

                                                              Binding describe how should we encode/decode the struct field

                                                              type Config

                                                              type Config struct {
                                                              	IndentionStep                 int
                                                              	MarshalFloatWith6Digits       bool
                                                              	EscapeHTML                    bool
                                                              	SortMapKeys                   bool
                                                              	UseNumber                     bool
                                                              	DisallowUnknownFields         bool
                                                              	TagKey                        string
                                                              	OnlyTaggedField               bool
                                                              	ValidateJsonRawMessage        bool
                                                              	ObjectFieldMustBeSimpleString bool
                                                              	CaseSensitive                 bool
                                                              }

                                                                Config customize how the API should behave. The API is created from Config by Froze.

                                                                func (Config) Froze

                                                                func (cfg Config) Froze() API

                                                                  Froze forge API from config

                                                                  type Decoder

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

                                                                    Decoder reads and decodes JSON values from an input stream. Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)

                                                                    func NewDecoder

                                                                    func NewDecoder(reader io.Reader) *Decoder

                                                                      NewDecoder adapts to json/stream NewDecoder API.

                                                                      NewDecoder returns a new decoder that reads from r.

                                                                      Instead of a json/encoding Decoder, an Decoder is returned Refer to https://godoc.org/encoding/json#NewDecoder for more information

                                                                      func (*Decoder) Buffered

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

                                                                        Buffered remaining buffer

                                                                        func (*Decoder) Decode

                                                                        func (adapter *Decoder) Decode(obj interface{}) error

                                                                          Decode decode JSON into interface{}

                                                                          func (*Decoder) DisallowUnknownFields

                                                                          func (adapter *Decoder) DisallowUnknownFields()

                                                                            DisallowUnknownFields causes the Decoder to return an error when the destination is a struct and the input contains object keys which do not match any non-ignored, exported fields in the destination.

                                                                            func (*Decoder) More

                                                                            func (adapter *Decoder) More() bool

                                                                              More is there more?

                                                                              func (*Decoder) UseNumber

                                                                              func (adapter *Decoder) UseNumber()

                                                                                UseNumber causes the Decoder to unmarshal a number into an interface{} as a Number instead of as a float64.

                                                                                type DecoderExtension

                                                                                type DecoderExtension map[reflect2.Type]ValDecoder

                                                                                func (DecoderExtension) CreateDecoder

                                                                                func (extension DecoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder

                                                                                  CreateDecoder get decoder from map

                                                                                  func (DecoderExtension) CreateEncoder

                                                                                  func (extension DecoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder

                                                                                    CreateEncoder No-op

                                                                                    func (DecoderExtension) CreateMapKeyDecoder

                                                                                    func (extension DecoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder

                                                                                      CreateMapKeyDecoder No-op

                                                                                      func (DecoderExtension) CreateMapKeyEncoder

                                                                                      func (extension DecoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder

                                                                                        CreateMapKeyEncoder No-op

                                                                                        func (DecoderExtension) DecorateDecoder

                                                                                        func (extension DecoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder

                                                                                          DecorateDecoder No-op

                                                                                          func (DecoderExtension) DecorateEncoder

                                                                                          func (extension DecoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder

                                                                                            DecorateEncoder No-op

                                                                                            func (DecoderExtension) UpdateStructDescriptor

                                                                                            func (extension DecoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor)

                                                                                              UpdateStructDescriptor No-op

                                                                                              type DecoderFunc

                                                                                              type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)

                                                                                                DecoderFunc the function form of TypeDecoder

                                                                                                type DummyExtension

                                                                                                type DummyExtension struct {
                                                                                                }

                                                                                                  DummyExtension embed this type get dummy implementation for all methods of Extension

                                                                                                  func (*DummyExtension) CreateDecoder

                                                                                                  func (extension *DummyExtension) CreateDecoder(typ reflect2.Type) ValDecoder

                                                                                                    CreateDecoder No-op

                                                                                                    func (*DummyExtension) CreateEncoder

                                                                                                    func (extension *DummyExtension) CreateEncoder(typ reflect2.Type) ValEncoder

                                                                                                      CreateEncoder No-op

                                                                                                      func (*DummyExtension) CreateMapKeyDecoder

                                                                                                      func (extension *DummyExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder

                                                                                                        CreateMapKeyDecoder No-op

                                                                                                        func (*DummyExtension) CreateMapKeyEncoder

                                                                                                        func (extension *DummyExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder

                                                                                                          CreateMapKeyEncoder No-op

                                                                                                          func (*DummyExtension) DecorateDecoder

                                                                                                          func (extension *DummyExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder

                                                                                                            DecorateDecoder No-op

                                                                                                            func (*DummyExtension) DecorateEncoder

                                                                                                            func (extension *DummyExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder

                                                                                                              DecorateEncoder No-op

                                                                                                              func (*DummyExtension) UpdateStructDescriptor

                                                                                                              func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor)

                                                                                                                UpdateStructDescriptor No-op

                                                                                                                type Encoder

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

                                                                                                                  Encoder same as json.Encoder

                                                                                                                  func NewEncoder

                                                                                                                  func NewEncoder(writer io.Writer) *Encoder

                                                                                                                    NewEncoder same as json.NewEncoder

                                                                                                                    func (*Encoder) Encode

                                                                                                                    func (adapter *Encoder) Encode(val interface{}) error

                                                                                                                      Encode encode interface{} as JSON to io.Writer

                                                                                                                      func (*Encoder) SetEscapeHTML

                                                                                                                      func (adapter *Encoder) SetEscapeHTML(escapeHTML bool)

                                                                                                                        SetEscapeHTML escape html by default, set to false to disable

                                                                                                                        func (*Encoder) SetIndent

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

                                                                                                                          SetIndent set the indention. Prefix is not supported

                                                                                                                          type EncoderExtension

                                                                                                                          type EncoderExtension map[reflect2.Type]ValEncoder

                                                                                                                          func (EncoderExtension) CreateDecoder

                                                                                                                          func (extension EncoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder

                                                                                                                            CreateDecoder No-op

                                                                                                                            func (EncoderExtension) CreateEncoder

                                                                                                                            func (extension EncoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder

                                                                                                                              CreateEncoder get encoder from map

                                                                                                                              func (EncoderExtension) CreateMapKeyDecoder

                                                                                                                              func (extension EncoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder

                                                                                                                                CreateMapKeyDecoder No-op

                                                                                                                                func (EncoderExtension) CreateMapKeyEncoder

                                                                                                                                func (extension EncoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder

                                                                                                                                  CreateMapKeyEncoder No-op

                                                                                                                                  func (EncoderExtension) DecorateDecoder

                                                                                                                                  func (extension EncoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder

                                                                                                                                    DecorateDecoder No-op

                                                                                                                                    func (EncoderExtension) DecorateEncoder

                                                                                                                                    func (extension EncoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder

                                                                                                                                      DecorateEncoder No-op

                                                                                                                                      func (EncoderExtension) UpdateStructDescriptor

                                                                                                                                      func (extension EncoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor)

                                                                                                                                        UpdateStructDescriptor No-op

                                                                                                                                        type EncoderFunc

                                                                                                                                        type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)

                                                                                                                                          EncoderFunc the function form of TypeEncoder

                                                                                                                                          type Extension

                                                                                                                                          type Extension interface {
                                                                                                                                          	UpdateStructDescriptor(structDescriptor *StructDescriptor)
                                                                                                                                          	CreateMapKeyDecoder(typ reflect2.Type) ValDecoder
                                                                                                                                          	CreateMapKeyEncoder(typ reflect2.Type) ValEncoder
                                                                                                                                          	CreateDecoder(typ reflect2.Type) ValDecoder
                                                                                                                                          	CreateEncoder(typ reflect2.Type) ValEncoder
                                                                                                                                          	DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder
                                                                                                                                          	DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder
                                                                                                                                          }

                                                                                                                                            Extension the one for all SPI. Customize encoding/decoding by specifying alternate encoder/decoder. Can also rename fields by UpdateStructDescriptor.

                                                                                                                                            type IsEmbeddedPtrNil

                                                                                                                                            type IsEmbeddedPtrNil interface {
                                                                                                                                            	IsEmbeddedPtrNil(ptr unsafe.Pointer) bool
                                                                                                                                            }

                                                                                                                                            type Iterator

                                                                                                                                            type Iterator struct {
                                                                                                                                            	Error      error
                                                                                                                                            	Attachment interface{} // open for customized decoder
                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                            }

                                                                                                                                              Iterator is a io.Reader like object, with JSON specific read functions. Error is not returned as return value, but stored as Error member on this iterator instance.

                                                                                                                                              func NewIterator

                                                                                                                                              func NewIterator(cfg API) *Iterator

                                                                                                                                                NewIterator creates an empty Iterator instance

                                                                                                                                                func Parse

                                                                                                                                                func Parse(cfg API, reader io.Reader, bufSize int) *Iterator

                                                                                                                                                  Parse creates an Iterator instance from io.Reader

                                                                                                                                                  func ParseBytes

                                                                                                                                                  func ParseBytes(cfg API, input []byte) *Iterator

                                                                                                                                                    ParseBytes creates an Iterator instance from byte array

                                                                                                                                                    func ParseString

                                                                                                                                                    func ParseString(cfg API, input string) *Iterator

                                                                                                                                                      ParseString creates an Iterator instance from string

                                                                                                                                                      func (*Iterator) CurrentBuffer

                                                                                                                                                      func (iter *Iterator) CurrentBuffer() string

                                                                                                                                                        CurrentBuffer gets current buffer as string for debugging purpose

                                                                                                                                                        func (*Iterator) Pool

                                                                                                                                                        func (iter *Iterator) Pool() IteratorPool

                                                                                                                                                          Pool returns a pool can provide more iterator with same configuration

                                                                                                                                                          func (*Iterator) Read

                                                                                                                                                          func (iter *Iterator) Read() interface{}

                                                                                                                                                            Read read the next JSON element as generic interface{}.

                                                                                                                                                            func (*Iterator) ReadAny

                                                                                                                                                            func (iter *Iterator) ReadAny() Any

                                                                                                                                                              ReadAny read next JSON element as an Any object. It is a better json.RawMessage.

                                                                                                                                                              func (*Iterator) ReadArray

                                                                                                                                                              func (iter *Iterator) ReadArray() (ret bool)

                                                                                                                                                                ReadArray read array element, tells if the array has more element to read.

                                                                                                                                                                func (*Iterator) ReadArrayCB

                                                                                                                                                                func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool)

                                                                                                                                                                  ReadArrayCB read array with callback

                                                                                                                                                                  func (*Iterator) ReadBigFloat

                                                                                                                                                                  func (iter *Iterator) ReadBigFloat() (ret *big.Float)

                                                                                                                                                                    ReadBigFloat read big.Float

                                                                                                                                                                    func (*Iterator) ReadBigInt

                                                                                                                                                                    func (iter *Iterator) ReadBigInt() (ret *big.Int)

                                                                                                                                                                      ReadBigInt read big.Int

                                                                                                                                                                      func (*Iterator) ReadBool

                                                                                                                                                                      func (iter *Iterator) ReadBool() (ret bool)

                                                                                                                                                                        ReadBool reads a json object as BoolValue

                                                                                                                                                                        func (*Iterator) ReadFloat32

                                                                                                                                                                        func (iter *Iterator) ReadFloat32() (ret float32)

                                                                                                                                                                          ReadFloat32 read float32

                                                                                                                                                                          func (*Iterator) ReadFloat64

                                                                                                                                                                          func (iter *Iterator) ReadFloat64() (ret float64)

                                                                                                                                                                            ReadFloat64 read float64

                                                                                                                                                                            func (*Iterator) ReadInt

                                                                                                                                                                            func (iter *Iterator) ReadInt() int

                                                                                                                                                                              ReadInt read int

                                                                                                                                                                              func (*Iterator) ReadInt16

                                                                                                                                                                              func (iter *Iterator) ReadInt16() (ret int16)

                                                                                                                                                                                ReadInt16 read int16

                                                                                                                                                                                func (*Iterator) ReadInt32

                                                                                                                                                                                func (iter *Iterator) ReadInt32() (ret int32)

                                                                                                                                                                                  ReadInt32 read int32

                                                                                                                                                                                  func (*Iterator) ReadInt64

                                                                                                                                                                                  func (iter *Iterator) ReadInt64() (ret int64)

                                                                                                                                                                                    ReadInt64 read int64

                                                                                                                                                                                    func (*Iterator) ReadInt8

                                                                                                                                                                                    func (iter *Iterator) ReadInt8() (ret int8)

                                                                                                                                                                                      ReadInt8 read int8

                                                                                                                                                                                      func (*Iterator) ReadMapCB

                                                                                                                                                                                      func (iter *Iterator) ReadMapCB(callback func(*Iterator, string) bool) bool

                                                                                                                                                                                        ReadMapCB read map with callback, the key can be any string

                                                                                                                                                                                        func (*Iterator) ReadNil

                                                                                                                                                                                        func (iter *Iterator) ReadNil() (ret bool)

                                                                                                                                                                                          ReadNil reads a json object as nil and returns whether it's a nil or not

                                                                                                                                                                                          func (*Iterator) ReadNumber

                                                                                                                                                                                          func (iter *Iterator) ReadNumber() (ret json.Number)

                                                                                                                                                                                            ReadNumber read json.Number

                                                                                                                                                                                            func (*Iterator) ReadObject

                                                                                                                                                                                            func (iter *Iterator) ReadObject() (ret string)

                                                                                                                                                                                              ReadObject read one field from object. If object ended, returns empty string. Otherwise, returns the field name.

                                                                                                                                                                                              func (*Iterator) ReadObjectCB

                                                                                                                                                                                              func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool

                                                                                                                                                                                                ReadObjectCB read object with callback, the key is ascii only and field name not copied

                                                                                                                                                                                                func (*Iterator) ReadString

                                                                                                                                                                                                func (iter *Iterator) ReadString() (ret string)

                                                                                                                                                                                                  ReadString read string from iterator

                                                                                                                                                                                                  func (*Iterator) ReadStringAsSlice

                                                                                                                                                                                                  func (iter *Iterator) ReadStringAsSlice() (ret []byte)

                                                                                                                                                                                                    ReadStringAsSlice read string from iterator without copying into string form. The []byte can not be kept, as it will change after next iterator call.

                                                                                                                                                                                                    func (*Iterator) ReadUint

                                                                                                                                                                                                    func (iter *Iterator) ReadUint() uint

                                                                                                                                                                                                      ReadUint read uint

                                                                                                                                                                                                      func (*Iterator) ReadUint16

                                                                                                                                                                                                      func (iter *Iterator) ReadUint16() (ret uint16)

                                                                                                                                                                                                        ReadUint16 read uint16

                                                                                                                                                                                                        func (*Iterator) ReadUint32

                                                                                                                                                                                                        func (iter *Iterator) ReadUint32() (ret uint32)

                                                                                                                                                                                                          ReadUint32 read uint32

                                                                                                                                                                                                          func (*Iterator) ReadUint64

                                                                                                                                                                                                          func (iter *Iterator) ReadUint64() uint64

                                                                                                                                                                                                            ReadUint64 read uint64

                                                                                                                                                                                                            func (*Iterator) ReadUint8

                                                                                                                                                                                                            func (iter *Iterator) ReadUint8() (ret uint8)

                                                                                                                                                                                                              ReadUint8 read uint8

                                                                                                                                                                                                              func (*Iterator) ReadVal

                                                                                                                                                                                                              func (iter *Iterator) ReadVal(obj interface{})

                                                                                                                                                                                                                ReadVal copy the underlying JSON into go interface, same as json.Unmarshal

                                                                                                                                                                                                                func (*Iterator) ReportError

                                                                                                                                                                                                                func (iter *Iterator) ReportError(operation string, msg string)

                                                                                                                                                                                                                  ReportError record a error in iterator instance with current position.

                                                                                                                                                                                                                  func (*Iterator) Reset

                                                                                                                                                                                                                  func (iter *Iterator) Reset(reader io.Reader) *Iterator

                                                                                                                                                                                                                    Reset reuse iterator instance by specifying another reader

                                                                                                                                                                                                                    func (*Iterator) ResetBytes

                                                                                                                                                                                                                    func (iter *Iterator) ResetBytes(input []byte) *Iterator

                                                                                                                                                                                                                      ResetBytes reuse iterator instance by specifying another byte array as input

                                                                                                                                                                                                                      func (*Iterator) Skip

                                                                                                                                                                                                                      func (iter *Iterator) Skip()

                                                                                                                                                                                                                        Skip skips a json object and positions to relatively the next json object

                                                                                                                                                                                                                        func (*Iterator) SkipAndAppendBytes

                                                                                                                                                                                                                        func (iter *Iterator) SkipAndAppendBytes(buf []byte) []byte

                                                                                                                                                                                                                          SkipAndAppendBytes skips next JSON element and appends its content to buffer, returning the result.

                                                                                                                                                                                                                          func (*Iterator) SkipAndReturnBytes

                                                                                                                                                                                                                          func (iter *Iterator) SkipAndReturnBytes() []byte

                                                                                                                                                                                                                            SkipAndReturnBytes skip next JSON element, and return its content as []byte. The []byte can be kept, it is a copy of data.

                                                                                                                                                                                                                            func (*Iterator) WhatIsNext

                                                                                                                                                                                                                            func (iter *Iterator) WhatIsNext() ValueType

                                                                                                                                                                                                                              WhatIsNext gets ValueType of relatively next json element

                                                                                                                                                                                                                              type IteratorPool

                                                                                                                                                                                                                              type IteratorPool interface {
                                                                                                                                                                                                                              	BorrowIterator(data []byte) *Iterator
                                                                                                                                                                                                                              	ReturnIterator(iter *Iterator)
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                IteratorPool a thread safe pool of iterators with same configuration

                                                                                                                                                                                                                                type Number

                                                                                                                                                                                                                                type Number string

                                                                                                                                                                                                                                func (Number) Float64

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

                                                                                                                                                                                                                                  Float64 returns the number as a float64.

                                                                                                                                                                                                                                  func (Number) Int64

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

                                                                                                                                                                                                                                    Int64 returns the number as an int64.

                                                                                                                                                                                                                                    func (Number) String

                                                                                                                                                                                                                                    func (n Number) String() string

                                                                                                                                                                                                                                      String returns the literal text of the number.

                                                                                                                                                                                                                                      type OptionalDecoder

                                                                                                                                                                                                                                      type OptionalDecoder struct {
                                                                                                                                                                                                                                      	ValueType    reflect2.Type
                                                                                                                                                                                                                                      	ValueDecoder ValDecoder
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                      func (*OptionalDecoder) Decode

                                                                                                                                                                                                                                      func (decoder *OptionalDecoder) Decode(ptr unsafe.Pointer, iter *Iterator)

                                                                                                                                                                                                                                      type OptionalEncoder

                                                                                                                                                                                                                                      type OptionalEncoder struct {
                                                                                                                                                                                                                                      	ValueEncoder ValEncoder
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                      func (*OptionalEncoder) Encode

                                                                                                                                                                                                                                      func (encoder *OptionalEncoder) Encode(ptr unsafe.Pointer, stream *Stream)

                                                                                                                                                                                                                                      func (*OptionalEncoder) IsEmpty

                                                                                                                                                                                                                                      func (encoder *OptionalEncoder) IsEmpty(ptr unsafe.Pointer) bool

                                                                                                                                                                                                                                      type RawMessage

                                                                                                                                                                                                                                      type RawMessage []byte

                                                                                                                                                                                                                                        RawMessage to make replace json with jsoniter

                                                                                                                                                                                                                                        type Stream

                                                                                                                                                                                                                                        type Stream struct {
                                                                                                                                                                                                                                        	Error error
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	Attachment interface{} // open for customized encoder
                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          stream is a io.Writer like object, with JSON specific write functions. Error is not returned as return value, but stored as Error member on this stream instance.

                                                                                                                                                                                                                                          func NewStream

                                                                                                                                                                                                                                          func NewStream(cfg API, out io.Writer, bufSize int) *Stream

                                                                                                                                                                                                                                            NewStream create new stream instance. cfg can be jsoniter.ConfigDefault. out can be nil if write to internal buffer. bufSize is the initial size for the internal buffer in bytes.

                                                                                                                                                                                                                                            func (*Stream) Available

                                                                                                                                                                                                                                            func (stream *Stream) Available() int

                                                                                                                                                                                                                                              Available returns how many bytes are unused in the buffer.

                                                                                                                                                                                                                                              func (*Stream) Buffer

                                                                                                                                                                                                                                              func (stream *Stream) Buffer() []byte

                                                                                                                                                                                                                                                Buffer if writer is nil, use this method to take the result

                                                                                                                                                                                                                                                func (*Stream) Buffered

                                                                                                                                                                                                                                                func (stream *Stream) Buffered() int

                                                                                                                                                                                                                                                  Buffered returns the number of bytes that have been written into the current buffer.

                                                                                                                                                                                                                                                  func (*Stream) Flush

                                                                                                                                                                                                                                                  func (stream *Stream) Flush() error

                                                                                                                                                                                                                                                    Flush writes any buffered data to the underlying io.Writer.

                                                                                                                                                                                                                                                    func (*Stream) Pool

                                                                                                                                                                                                                                                    func (stream *Stream) Pool() StreamPool

                                                                                                                                                                                                                                                      Pool returns a pool can provide more stream with same configuration

                                                                                                                                                                                                                                                      func (*Stream) Reset

                                                                                                                                                                                                                                                      func (stream *Stream) Reset(out io.Writer)

                                                                                                                                                                                                                                                        Reset reuse this stream instance by assign a new writer

                                                                                                                                                                                                                                                        func (*Stream) SetBuffer

                                                                                                                                                                                                                                                        func (stream *Stream) SetBuffer(buf []byte)

                                                                                                                                                                                                                                                          SetBuffer allows to append to the internal buffer directly

                                                                                                                                                                                                                                                          func (*Stream) Write

                                                                                                                                                                                                                                                          func (stream *Stream) Write(p []byte) (nn int, err error)

                                                                                                                                                                                                                                                            Write writes the contents of p into the buffer. It returns the number of bytes written. If nn < len(p), it also returns an error explaining why the write is short.

                                                                                                                                                                                                                                                            func (*Stream) WriteArrayEnd

                                                                                                                                                                                                                                                            func (stream *Stream) WriteArrayEnd()

                                                                                                                                                                                                                                                              WriteArrayEnd write ] with possible indention

                                                                                                                                                                                                                                                              func (*Stream) WriteArrayStart

                                                                                                                                                                                                                                                              func (stream *Stream) WriteArrayStart()

                                                                                                                                                                                                                                                                WriteArrayStart write [ with possible indention

                                                                                                                                                                                                                                                                func (*Stream) WriteBool

                                                                                                                                                                                                                                                                func (stream *Stream) WriteBool(val bool)

                                                                                                                                                                                                                                                                  WriteBool write true or false into stream

                                                                                                                                                                                                                                                                  func (*Stream) WriteEmptyArray

                                                                                                                                                                                                                                                                  func (stream *Stream) WriteEmptyArray()

                                                                                                                                                                                                                                                                    WriteEmptyArray write []

                                                                                                                                                                                                                                                                    func (*Stream) WriteEmptyObject

                                                                                                                                                                                                                                                                    func (stream *Stream) WriteEmptyObject()

                                                                                                                                                                                                                                                                      WriteEmptyObject write {}

                                                                                                                                                                                                                                                                      func (*Stream) WriteFalse

                                                                                                                                                                                                                                                                      func (stream *Stream) WriteFalse()

                                                                                                                                                                                                                                                                        WriteFalse write false to stream

                                                                                                                                                                                                                                                                        func (*Stream) WriteFloat32

                                                                                                                                                                                                                                                                        func (stream *Stream) WriteFloat32(val float32)

                                                                                                                                                                                                                                                                          WriteFloat32 write float32 to stream

                                                                                                                                                                                                                                                                          func (*Stream) WriteFloat32Lossy

                                                                                                                                                                                                                                                                          func (stream *Stream) WriteFloat32Lossy(val float32)

                                                                                                                                                                                                                                                                            WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster

                                                                                                                                                                                                                                                                            func (*Stream) WriteFloat64

                                                                                                                                                                                                                                                                            func (stream *Stream) WriteFloat64(val float64)

                                                                                                                                                                                                                                                                              WriteFloat64 write float64 to stream

                                                                                                                                                                                                                                                                              func (*Stream) WriteFloat64Lossy

                                                                                                                                                                                                                                                                              func (stream *Stream) WriteFloat64Lossy(val float64)

                                                                                                                                                                                                                                                                                WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster

                                                                                                                                                                                                                                                                                func (*Stream) WriteInt

                                                                                                                                                                                                                                                                                func (stream *Stream) WriteInt(val int)

                                                                                                                                                                                                                                                                                  WriteInt write int to stream

                                                                                                                                                                                                                                                                                  func (*Stream) WriteInt16

                                                                                                                                                                                                                                                                                  func (stream *Stream) WriteInt16(nval int16)

                                                                                                                                                                                                                                                                                    WriteInt16 write int16 to stream

                                                                                                                                                                                                                                                                                    func (*Stream) WriteInt32

                                                                                                                                                                                                                                                                                    func (stream *Stream) WriteInt32(nval int32)

                                                                                                                                                                                                                                                                                      WriteInt32 write int32 to stream

                                                                                                                                                                                                                                                                                      func (*Stream) WriteInt64

                                                                                                                                                                                                                                                                                      func (stream *Stream) WriteInt64(nval int64)

                                                                                                                                                                                                                                                                                        WriteInt64 write int64 to stream

                                                                                                                                                                                                                                                                                        func (*Stream) WriteInt8

                                                                                                                                                                                                                                                                                        func (stream *Stream) WriteInt8(nval int8)

                                                                                                                                                                                                                                                                                          WriteInt8 write int8 to stream

                                                                                                                                                                                                                                                                                          func (*Stream) WriteMore

                                                                                                                                                                                                                                                                                          func (stream *Stream) WriteMore()

                                                                                                                                                                                                                                                                                            WriteMore write , with possible indention

                                                                                                                                                                                                                                                                                            func (*Stream) WriteNil

                                                                                                                                                                                                                                                                                            func (stream *Stream) WriteNil()

                                                                                                                                                                                                                                                                                              WriteNil write null to stream

                                                                                                                                                                                                                                                                                              func (*Stream) WriteObjectEnd

                                                                                                                                                                                                                                                                                              func (stream *Stream) WriteObjectEnd()

                                                                                                                                                                                                                                                                                                WriteObjectEnd write } with possible indention

                                                                                                                                                                                                                                                                                                func (*Stream) WriteObjectField

                                                                                                                                                                                                                                                                                                func (stream *Stream) WriteObjectField(field string)

                                                                                                                                                                                                                                                                                                  WriteObjectField write "field": with possible indention

                                                                                                                                                                                                                                                                                                  func (*Stream) WriteObjectStart

                                                                                                                                                                                                                                                                                                  func (stream *Stream) WriteObjectStart()

                                                                                                                                                                                                                                                                                                    WriteObjectStart write { with possible indention

                                                                                                                                                                                                                                                                                                    func (*Stream) WriteRaw

                                                                                                                                                                                                                                                                                                    func (stream *Stream) WriteRaw(s string)

                                                                                                                                                                                                                                                                                                      WriteRaw write string out without quotes, just like []byte

                                                                                                                                                                                                                                                                                                      func (*Stream) WriteString

                                                                                                                                                                                                                                                                                                      func (stream *Stream) WriteString(s string)

                                                                                                                                                                                                                                                                                                        WriteString write string to stream without html escape

                                                                                                                                                                                                                                                                                                        func (*Stream) WriteStringWithHTMLEscaped

                                                                                                                                                                                                                                                                                                        func (stream *Stream) WriteStringWithHTMLEscaped(s string)

                                                                                                                                                                                                                                                                                                          WriteStringWithHTMLEscaped write string to stream with html special characters escaped

                                                                                                                                                                                                                                                                                                          func (*Stream) WriteTrue

                                                                                                                                                                                                                                                                                                          func (stream *Stream) WriteTrue()

                                                                                                                                                                                                                                                                                                            WriteTrue write true to stream

                                                                                                                                                                                                                                                                                                            func (*Stream) WriteUint

                                                                                                                                                                                                                                                                                                            func (stream *Stream) WriteUint(val uint)

                                                                                                                                                                                                                                                                                                              WriteUint write uint to stream

                                                                                                                                                                                                                                                                                                              func (*Stream) WriteUint16

                                                                                                                                                                                                                                                                                                              func (stream *Stream) WriteUint16(val uint16)

                                                                                                                                                                                                                                                                                                                WriteUint16 write uint16 to stream

                                                                                                                                                                                                                                                                                                                func (*Stream) WriteUint32

                                                                                                                                                                                                                                                                                                                func (stream *Stream) WriteUint32(val uint32)

                                                                                                                                                                                                                                                                                                                  WriteUint32 write uint32 to stream

                                                                                                                                                                                                                                                                                                                  func (*Stream) WriteUint64

                                                                                                                                                                                                                                                                                                                  func (stream *Stream) WriteUint64(val uint64)

                                                                                                                                                                                                                                                                                                                    WriteUint64 write uint64 to stream

                                                                                                                                                                                                                                                                                                                    func (*Stream) WriteUint8

                                                                                                                                                                                                                                                                                                                    func (stream *Stream) WriteUint8(val uint8)

                                                                                                                                                                                                                                                                                                                      WriteUint8 write uint8 to stream

                                                                                                                                                                                                                                                                                                                      func (*Stream) WriteVal

                                                                                                                                                                                                                                                                                                                      func (stream *Stream) WriteVal(val interface{})

                                                                                                                                                                                                                                                                                                                        WriteVal copy the go interface into underlying JSON, same as json.Marshal

                                                                                                                                                                                                                                                                                                                        type StreamPool

                                                                                                                                                                                                                                                                                                                        type StreamPool interface {
                                                                                                                                                                                                                                                                                                                        	BorrowStream(writer io.Writer) *Stream
                                                                                                                                                                                                                                                                                                                        	ReturnStream(stream *Stream)
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          StreamPool a thread safe pool of streams with same configuration

                                                                                                                                                                                                                                                                                                                          type StructDescriptor

                                                                                                                                                                                                                                                                                                                          type StructDescriptor struct {
                                                                                                                                                                                                                                                                                                                          	Type   reflect2.Type
                                                                                                                                                                                                                                                                                                                          	Fields []*Binding
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            StructDescriptor describe how should we encode/decode the struct

                                                                                                                                                                                                                                                                                                                            func (*StructDescriptor) GetField

                                                                                                                                                                                                                                                                                                                            func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding

                                                                                                                                                                                                                                                                                                                              GetField get one field from the descriptor by its name. Can not use map here to keep field orders.

                                                                                                                                                                                                                                                                                                                              type ValDecoder

                                                                                                                                                                                                                                                                                                                              type ValDecoder interface {
                                                                                                                                                                                                                                                                                                                              	Decode(ptr unsafe.Pointer, iter *Iterator)
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                ValDecoder is an internal type registered to cache as needed. Don't confuse jsoniter.ValDecoder with json.Decoder. For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link).

                                                                                                                                                                                                                                                                                                                                Reflection on type to create decoders, which is then cached Reflection on value is avoided as we can, as the reflect.Value itself will allocate, with following exceptions 1. create instance of new value, for example *int will need a int to be allocated 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New 3. assignment to map, both key and value will be reflect.Value For a simple struct binding, it will be reflect.Value free and allocation free

                                                                                                                                                                                                                                                                                                                                type ValEncoder

                                                                                                                                                                                                                                                                                                                                type ValEncoder interface {
                                                                                                                                                                                                                                                                                                                                	IsEmpty(ptr unsafe.Pointer) bool
                                                                                                                                                                                                                                                                                                                                	Encode(ptr unsafe.Pointer, stream *Stream)
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  ValEncoder is an internal type registered to cache as needed. Don't confuse jsoniter.ValEncoder with json.Encoder. For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).

                                                                                                                                                                                                                                                                                                                                  type ValueType

                                                                                                                                                                                                                                                                                                                                  type ValueType int

                                                                                                                                                                                                                                                                                                                                    ValueType the type for JSON element

                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                    	// InvalidValue invalid JSON element
                                                                                                                                                                                                                                                                                                                                    	InvalidValue ValueType = iota
                                                                                                                                                                                                                                                                                                                                    	// StringValue JSON element "string"
                                                                                                                                                                                                                                                                                                                                    	StringValue
                                                                                                                                                                                                                                                                                                                                    	// NumberValue JSON element 100 or 0.10
                                                                                                                                                                                                                                                                                                                                    	NumberValue
                                                                                                                                                                                                                                                                                                                                    	// NilValue JSON element null
                                                                                                                                                                                                                                                                                                                                    	NilValue
                                                                                                                                                                                                                                                                                                                                    	// BoolValue JSON element true or false
                                                                                                                                                                                                                                                                                                                                    	BoolValue
                                                                                                                                                                                                                                                                                                                                    	// ArrayValue JSON element []
                                                                                                                                                                                                                                                                                                                                    	ArrayValue
                                                                                                                                                                                                                                                                                                                                    	// ObjectValue JSON element {}
                                                                                                                                                                                                                                                                                                                                    	ObjectValue
                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                    Directories

                                                                                                                                                                                                                                                                                                                                    Path Synopsis