evanphx/json-patch

To install the latest version of the jsonpatch library, use the following command:

go get -u github.com/evanphx/json-patch/v5

If you specifically require version 4, use:

go get -u gopkg.in/evanphx/json-patch.v4

To check if two JSON documents are structurally identical (ignoring whitespace and key ordering), use jsonpatch.Equal(document1, document2). This is safer than comparing raw byte arrays or strings.

package main

import (
	"fmt"

	jsonpatch "github.com/evanphx/json-patch"
)

func main() {
	original := []byte(`{"name": "John", "age": 24, "height": 3.21}`)
	similar := []byte(`
		{
			"age": 24,
			"height": 3.21,
			"name": "John"
		}
	`)
	different := []byte(`{"name": "Jane", "age": 20, "height": 3.37}`)

	if jsonpatch.Equal(original, similar) {
		fmt.Println(`"original" is structurally equal to "similar"`)
	}

	if !jsonpatch.Equal(original, different) {
		fmt.Println(`"original" is _not_ structurally equal to "different"`)
	}
}

To work with RFC6902 JSON Patches (sequences of operations like add, remove, replace), use jsonpatch.DecodePatch([]byte) to create a patch object. You can then call the .Apply(document) method on that patch object to modify a JSON document.

package main

import (
	"fmt"

	jsonpatch "github.com/evanphx/json-patch"
)

func main() {
	original := []byte(`{"name": "John", "age": 24, "height": 3.21}`)
	patchJSON := []byte(`[
		{"op": "replace", "path": "/name", "value": "Jane"},
		{"op": "remove", "path": "/height"}
	]`)

	patch, err := jsonpatch.DecodePatch(patchJSON)
	if err != nil {
		panic(err)
	}

	modified, err := patch.Apply(original)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Original document: %s\n", original)
	fmt.Printf("Modified document: %s\n", modified)
}

Use NewApplyOptions to get a default configuration, then modify the fields to control patch behavior:

• SupportNegativeIndices (bool): If true, allows non-standard negative indices in array paths to reference elements from the end of the array. Default is true.
• AccumulatedCopySizeLimit (int64): Limits the total size increase in bytes caused by copy operations. If set to a value > 0, the patch will fail if this limit is exceeded.
• AllowMissingPathOnRemove (bool): If true, remove operations will not fail if the target path does not exist. Default is false.
• EnsurePathExistsOnAdd (bool): If true, add operations will recursively create missing parts of the path (creating objects or arrays as needed). Default is false.
• EscapeHTML (bool): Controls whether HTML characters are escaped during marshaling. Default is true.

The json-patch command-line tool allows you to apply one or more JSON patch files to a JSON document provided via stdin.

Installation:

go install github.com/evanphx/json-patch/cmd/json-patch

Usage: Use the -p flag to specify patch files. The tool will apply them in the order provided.

cat document.json | json-patch -p patch.1.json -p patch.2.json

Use MergeMergePatches(patch1Data, patch2Data []byte) to combine two separate merge patches into a single patch. The resulting patch, when applied to a document, will yield the same result as applying patch1 and then patch2 in succession.

Returns the combined patch as a byte slice or an error if the input is invalid.

The Patch type provides several methods to apply operations to a JSON document (byte slice):

• Apply(doc []byte): Applies the patch using default ApplyOptions and returns the mutated document.
• ApplyWithOptions(doc []byte, options *ApplyOptions): Applies the patch using custom configuration.
• ApplyIndent(doc []byte, indent string): Applies the patch and returns the result formatted with the specified indentation.
• ApplyIndentWithOptions(doc []byte, indent string, options *ApplyOptions): Applies the patch with both custom indentation and custom configuration.

An Operation is a map representing a single JSON-Patch step. You can extract specific fields using these methods:

• Kind() string: Returns the operation type (e.g., add, remove, replace, move, copy, test). Returns "unknown" if the field is missing or invalid.
• Path() (string, error): Returns the target path for the operation. Returns ErrMissing if the field is absent.
• From() (string, error): Returns the source path (used by move and copy). Returns ErrMissing if the field is absent.
• ValueInterface() (interface{}, error): Decodes the value field into a Go interface. Returns ErrMissing if the field is absent.