import "github.com/json-iterator/go"
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.
feature_adapter.go feature_any.go feature_any_array.go feature_any_bool.go feature_any_float.go feature_any_int32.go feature_any_int64.go feature_any_invalid.go feature_any_nil.go feature_any_number.go feature_any_object.go feature_any_string.go feature_any_uint32.go feature_any_uint64.go feature_config.go feature_iter.go feature_iter_array.go feature_iter_float.go feature_iter_int.go feature_iter_object.go feature_iter_skip.go feature_iter_string.go feature_pool.go feature_reflect.go feature_reflect_array.go feature_reflect_extension.go feature_reflect_map.go feature_reflect_native.go feature_reflect_object.go feature_reflect_slice.go feature_stream.go feature_stream_float.go feature_stream_int.go feature_stream_string.go
Trying to be 100% compatible with standard library behavior
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
Code:
type ColorGroup struct {
ID int
Name string
Colors []string
}
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
b, err := jsoniter.Marshal(group)
if err != nil {
fmt.Println("error:", err)
}
os.Stdout.Write(b)
Output:
{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
func RegisterFieldDecoder(typ string, field string, decoder ValDecoder)
func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc)
func RegisterFieldEncoder(typ string, field string, encoder ValEncoder)
func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool)
func RegisterTypeDecoder(typ string, decoder ValDecoder)
func RegisterTypeDecoderFunc(typ string, fun DecoderFunc)
func RegisterTypeEncoder(typ string, encoder ValEncoder)
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
Code:
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
type Animal struct {
Name string
Order string
}
var animals []Animal
err := jsoniter.Unmarshal(jsonBlob, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)
Output:
[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
func WriteToStream(val interface{}, stream *Stream, encoder ValEncoder)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
// TODO: add Set
Size() int
Keys() []string
// TODO: remove me
GetArray() []Any
// TODO: remove me
GetObject() map[string]Any
GetInterface() interface{}
WriteTo(stream *Stream)
}type Api interface {
MarshalToString(v interface{}) (string, error)
Marshal(v interface{}) ([]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
}type Binding struct {
Field *reflect.StructField
FromNames []string
ToNames []string
Encoder ValEncoder
Decoder ValDecoder
}type Config struct {
IndentionStep int
MarshalFloatWith6Digits bool
EscapeHtml bool
SortMapKeys bool
UseNumber bool
}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)
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
type DummyExtension struct {
}func (extension *DummyExtension) CreateDecoder(typ reflect.Type) ValDecoder
func (extension *DummyExtension) CreateEncoder(typ reflect.Type) ValEncoder
func (extension *DummyExtension) DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder
func (extension *DummyExtension) DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder
func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor)
type Encoder struct {
// contains filtered or unexported fields
}type Extension interface {
UpdateStructDescriptor(structDescriptor *StructDescriptor)
CreateDecoder(typ reflect.Type) ValDecoder
CreateEncoder(typ reflect.Type) ValEncoder
DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder
DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder
}Iterator is a fast and flexible JSON parser
Create creates an empty Iterator instance
Parse parses a json buffer in io.Reader into an Iterator instance
ParseBytes parses a json byte slice into an Iterator instance
ParseString parses a json string into an Iterator instance
CurrentBuffer gets current buffer as string
ReadBool reads a json object as Bool
ReadNil reads a json object as nil and returns whether it's a nil or not
Read converts an Iterator instance into go interface, same as json.Unmarshal
Reset can reset an Iterator instance for another json buffer in io.Reader
ResetBytes can reset an Iterator instance for another json byte slice
Skip skips a json object and positions to relatively the next json object
WhatIsNext gets ValueType of relatively next json object
Available returns how many bytes are unused in the buffer.
Buffered returns the number of bytes that have been written into the current buffer.
Flush writes any buffered data to the underlying io.Writer.
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 (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding
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 interface {
IsEmpty(ptr unsafe.Pointer) bool
Encode(ptr unsafe.Pointer, stream *Stream)
EncodeInterface(val interface{}, 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).
| Path | Synopsis |
|---|---|
| assert | |
| extra | |
| require |
Package jsoniter imports 19 packages (graph) and is imported by 2 packages. Updated 2017-06-23. Refresh now. Tools for package owners.