1
0
mirror of https://github.com/json-iterator/go.git synced 2025-06-06 22:36:25 +02:00
Rob Figueiredo 11a37a0774 (*Stream).WriteMore: remove implicit Flush
I believe that WriteMore should not call Flush for these reasons:

1. This is surprising for users because of inconsistency. Why call Flush in
   WriteMore and not in WriteObjectEnd?

2. It is not necessary; callers are free to call Flush if their use case demands
   it.

3. It harms performance in the common case by flushing the buffer much more
   frequently than it needs to be flushed.

The stream benchmark shows a 7% benefit to removing the Flush call, and I
observed a similar speedup in my real-world use case.

    benchmark                                        old ns/op     new ns/op     delta
    Benchmark_encode_string_with_SetEscapeHTML-8     442           437           -1.13%
    Benchmark_jsoniter_large_file-8                  21222         21062         -0.75%
    Benchmark_json_large_file-8                      40187         40266         +0.20%
    Benchmark_stream_encode_big_object-8             8611          7956          -7.61%

    benchmark                                        old allocs     new allocs     delta
    Benchmark_encode_string_with_SetEscapeHTML-8     6              6              +0.00%
    Benchmark_jsoniter_large_file-8                  78             78             +0.00%
    Benchmark_json_large_file-8                      13             13             +0.00%
    Benchmark_stream_encode_big_object-8             0              0              +0.00%

    benchmark                                        old bytes     new bytes     delta
    Benchmark_encode_string_with_SetEscapeHTML-8     760           760           +0.00%
    Benchmark_jsoniter_large_file-8                  4920          4920          +0.00%
    Benchmark_json_large_file-8                      6640          6640          +0.00%
    Benchmark_stream_encode_big_object-8             0             0             +0.00%

Backwards compatibility - I believe there is little to no risk that this breaks
callers. WriteMore does not leave the JSON in a valid state, so it must be
followed by other Write* methods. To get the finished JSON out, the caller must
already be calling Flush.
2020-01-17 22:14:50 -05:00
2018-09-13 21:48:13 +03:00
2019-10-08 11:17:01 -04:00
2019-10-28 23:05:10 -07:00
2017-11-30 10:42:24 +08:00
2017-09-07 17:12:42 +02:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:08:01 +08:00
2018-02-19 23:04:25 +08:00
2018-02-19 23:04:25 +08:00
2018-10-24 21:05:37 +08:00
2017-11-30 10:42:24 +08:00
2019-01-10 17:51:25 +01:00
2019-04-25 17:40:48 -03:00
2019-04-25 17:40:48 -03:00
2018-07-01 13:05:25 +08:00
2018-07-01 13:05:25 +08:00
2019-10-08 11:17:01 -04:00
2019-01-10 18:00:15 +01:00
2018-02-23 08:12:45 +08:00
2018-02-19 23:04:25 +08:00
2019-10-08 11:17:01 -04:00
2018-02-19 23:04:25 +08:00
2017-07-09 16:09:23 +08:00
2016-11-30 08:30:24 +08:00
2018-04-07 21:40:08 +10:00
2019-03-06 22:29:09 +08:00
2019-10-28 23:05:10 -07:00
2019-10-08 11:17:01 -04:00
2019-10-08 11:17:01 -04:00
2018-02-24 22:04:41 +08:00
2018-02-19 23:04:25 +08:00
2018-02-14 14:06:32 +08:00

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 "github.com/json-iterator/go"

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

Replace

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

with

import "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

Description
Languages
Go 99.9%
Shell 0.1%