jscan provides a high-performance zero-allocation JSON iterator for Go. It's not compatible with encoding/json and doesn't provide the usual Marshal/Unmarshal capabilities, instead it focuses on fast and efficient scanning over JSON strings with on-the-fly validation and error reporting.

jscan is tested against https://github.com/nst/JSONTestSuite, a comprehensive test suite for RFC 8259 compliant JSON parsers.

https://go.dev/play/p/v-VeiMO2fsJ

package main

import (
	"fmt"

	"github.com/romshark/jscan"
)

func main() {
	j := `{
		"s": "value",
		"t": true,
		"f": false,
		"0": null,
		"n": -9.123e3,
		"o0": {},
		"a0": [],
		"o": {
			"k": "\"v\"",
			"a": [
				true,
				null,
				"item",
				-67.02e9,
				["foo"]
			]
		},
		"a3": [
			0,
			{
				"a3.a3":8
			}
		]
	}`

	err := jscan.Scan(jscan.Options{
		CachePath:  true,
		EscapePath: true,
	}, j, func(i *jscan.Iterator) (err bool) {
		fmt.Printf("| value:\n")
		fmt.Printf("|  level:      %d\n", i.Level)
		if k := i.Key(); k != "" {
			fmt.Printf("|  key:        %q\n", i.Key())
		}
		fmt.Printf("|  valueType:  %s\n", i.ValueType)
		if v := i.Value(); v != "" {
			fmt.Printf("|  value:      %q\n", i.Value())
		}
		fmt.Printf("|  arrayIndex: %d\n", i.ArrayIndex)
		fmt.Printf("|  path:       '%s'\n", i.Path())
		return false // No Error, resume scanning
	})

	if err.IsErr() {
		fmt.Printf("ERR: %s\n", err)
		return
	}

}

The following results were recorded on an Apple M1 Max MBP running macOS 13.2.1

goos: darwin
goarch: arm64

Calculating statistics for a tiny JSON document ({"x":0}):

Calculating statistics for a small JSON document (335 bytes):

Calculating statistics for a large JSON document (26.1 MB):

Calculating statistics for an object that contains a key and a string value consisting entirely of escape sequences (~3KB):

Array of 1024 integers:

Array of 1024 floating point numbers:

Array of 1024 strings:

Array of 1024 nullable booleans:

Get by path:

Validation:

Tiny

Small

Large

Validating an object that contains a key and a string value consisting entirely of escape sequences (~3KB):

Unwinding Stack

Array of 1024 integers

Array of 1024 floats

Array of 1024 nullable booleans

Array of 1024 strings