There are grammatical errors in the English FAQ section:
https://github.com/alibaba/fastjson/wiki/FAQ(English-Version)

I propose that these grammatical errors be revised for readability.

Here are some examples below:
5. fastjson v.s. gson?
fastjson is 6 times faster than gson, here is the testing result: https://github.com/eishay/jvm-serializers/wiki/Staging-Results
fastjson is 6 tim

What did you do?

When I do this (from your docs):

guard let dataFromString = text.data(using: .utf8, allowLossyConversion: false) else {return} let json = JSON(data: dataFromString)

I get an error "Call can throw, but it is not marked with 'try' and the error is not handled"

I did this. I just want to confirm that is right. It worked for me.

`guard let dataFromString

I think we should patch test/CMakeLists.txt to always use -Wall -Werror on *nix and the corresponding MSVC flags. It is way too easy to overlook a warning in the CI output as #1797 has shown.

@nlohmann Thoughts?

I have this schema I want to implement but I am finding it very difficult to find documentation to perform the serialization and deserialization for C++. The existing tutorial and documentation do not seem to describe this scenario which I am assuming is quite common. Can someone point me to any example or documentation that describes this?

tb.fbs:

namespace TB;

table Proj {
idx:int64

Now when oss-fuzz provides pretty code coverage, it is easy to see which parts of the code are not fuzzed properly.
Identify what can be done, and add fuzzers targeting the uncovered code.

Currently, when SortMapKeys is set to true in Config, map keys are sorted using a standard alphanumeric sort. It should be possible to specify a custom map key sorting function to use, in order to prioritize certain map keys over others.

Example: Standard SortMapKeys behavior:

cfg := jsoniter.Config{
   SortMapKeys: true,
}.Froze()

m := map[string]int{
   "beta": 2,
   "alp

I'm dealing with a large, flat json payload that has 100+ keys in a map.

I hit panics when using EachKey with the full list of json keys:

goroutine 1 [running]:
panic(0x4e8ac0, 0xc42000a0f0)
    /home/niek/go17/src/runtime/panic.go:500 +0x1a1
github.com/buger/jsonparser.EachKey(0xc421480000, 0x11ac, 0x11ac, 0xc420050e30, 0xc4200da000, 0xaf, 0x100, 0x0)
    /home/niek/workspace/src/github.c

Hi! Kind of really impressed with your library ❤️

But I have some issues with UnknownField null values. It is reproducible with the following test

func TestUnknownFieldsProxyNullField(t *testing.T) {
	baseJson := `{"Field1":"123","Field2":null}`

	s := StructWithUnknownsProxy{}

	err := s.UnmarshalJSON([]byte(baseJson))
	if err != nil {
		t.Errorf("UnmarshalJSON didn't expec

If json contains the following string <!-- anything here <script> it will comment out the rest of HTML braking the website.

The problem?

Adding the :html_safe to encode/2 doesn't escape this sequence.

Reproduction

<script>
const a = "<!-- <script>"
</script>
<h1>This is commented out</h1>

Why is that?

Because of the HTML Spec https://html.spec.what

The documentation at Sitepoint is actually very much explanatory than the "official" one at jsoniter

I suggest you include the Sitepoint link in the official [jsoniter](http://jsonit

Could we get a function to just return the string type instead of a byte slice?

I often just need the string and noticed GetStringByte is actually converting the underlying string to a byte.

func (v *Value) GetString(keys ...string) string {
  v = v.Get(keys...)
  if v == nil || v.Type() != TypeString {
    ret

Since Akka stream is gaining usage and an increase in streaming JSON as the format it would be nice to see example of usage for cases like this SO question or a mention if spray-json is not the best option and if not what else to use.

[SO ISSUE](http://stackoverflow.com/questions/43923390/custom-spray-json-rootjsonformat-or-jsonformat-depending-on-value-in-json-object?noredirect=1#comment748904

I suggest Element be like this:

export interface ElementTag {
  type: 'element';
  name:string;
  ...
}

export interface ElementText {
  type: 'text';
  text: string;
}

...

export type Element =
  | ElementTag
  | ElementText
  ...
  ;

This is one of the best practice to define AST in TypeScript, and it actually match your design 100% perfectly. Plea

If the window size is under a certain size, the path and the tree view is too small to accommodate the buffer. A minimum size should be set to guarantee that it's still usable.

https://github.com/Homebrew/brew

Would be great if we macOS users could brew install jtc and manage upgrades automatically, rather than having to check back here periodically to download new binaries.

Thanks!

As the libraries themselves are not part of the repository, it would be really helpful to see which version was tested, so the numbers in the README can be put into perspective.

All exceptions in namespace JsonMachine\Exception should extend one common exception, say JsonMachineException, so that userland code can catch for only one type and catch anything from this library. Fell free to create pull request and participate :)