deep-diff

What is deep-diff?

The deep-diff npm package is a utility for identifying differences between two JavaScript objects. It helps in understanding changes between object versions and can be particularly useful in debugging and data tracking scenarios.

What are deep-diff's main functionalities?

Difference Detection

This feature allows you to detect differences between two objects. The code sample shows how to use the diff function to compare two objects and log the differences.

const diff = require('deep-diff').diff;
const lhs = { name: 'my object', detail: { it: 'has', an: 'array', with: ['a', 'few', 'elements'] } };
const rhs = { name: 'updated object', detail: { it: 'has', an: 'array', with: ['a', 'few', 'more', 'elements', { than: 'before' }] } };
const differences = diff(lhs, rhs);
console.log(differences);

Observing Changes

This feature allows you to observe changes and apply them to the original object. The code sample demonstrates how to observe differences and apply these changes to update the object.

const diff = require('deep-diff').observableDiff;
const applyChange = require('deep-diff').applyChange;
let obj = { name: 'original' };
let newObj = { name: 'updated' };
diff(obj, newObj, function (d) {
  applyChange(obj, newObj, d);
});
console.log(obj);

Other packages similar to deep-diff

lodash.isequal

Lodash's isEqual function provides a way to perform deep comparison between two values to determine if they are equivalent. Unlike deep-diff, lodash.isequal does not list the differences but checks for equality.

jsondiffpatch

jsondiffpatch is a library that can diff and patch JSON objects. Similar to deep-diff, it provides detailed differences between objects but also supports patching changes directly, which offers a more integrated approach to handling data changes.

README

deep-diff

deep-diff is a javascript/node.js module providing utility functions for working with the structural differences between objects.

Features

• Get the structural differences between two objects.
• Observe the structural differences between two objects.
• When structural differences represent change, apply change from one object to another.
• When structural differences represent change, selectively apply change from one object to another.

Installation

npm install deep-diff

Tests

Tests use mocha and expect.js, so if you clone the github repository you'll need to run:

npm install

... followed by ...

npm test

... or ...

mocha -R spec

Importing

nodejs

var deep = require('deep-diff')

browser

<script src="deep-diff-0.1.2.min.js"></script>

In a browser, deep-diff defines a global variable DeepDiff. If there is a conflict in the global namesapce you can restore the conflicting definition and assign deep-diff to another variable like this: var deep = DeepDiff.noConflict();.

Simple Examples

In order to describe differences, change revolves around an origin object. For consistency, the origin object is always the operand on the left-hand-side of operations. The comparand, which may contain changes, is always on the right-hand-side of operations.

var diff = require('deep-diff').diff;

var lhs = {
	name: 'my object',
	description: 'it\'s an object!',
	details: {
		it: 'has',
		an: 'array',
		with: ['a', 'few', 'elements']
	}
};

var rhs = {
	name: 'updated object',
	description: 'it\'s an object!',
	details: {
		it: 'has',
		an: 'array',
		with: ['a', 'few', 'more', 'elements', { than: 'before' }]
	}
};

var differences = diff(lhs, rhs);

The code snippet above would result in the following structure describing the differences:

[ { kind: 'E',
    path: [ 'name' ],
    lhs: 'my object',
    rhs: 'updated object' },
  { kind: 'A',
    path: [ 'details', 'with' ],
    index: 2,
    item: { kind: 'E', path: [], lhs: 'elements', rhs: 'more' } },
  { kind: 'A',
    path: [ 'details', 'with' ],
    index: 3,
    item: { kind: 'N', rhs: 'elements' } },
  { kind: 'A',
    path: [ 'details', 'with' ],
    index: 4,
    item: { kind: 'N', rhs: { than: 'before' } } } ]

Differences

Differences are reported as one or more change records. Change records have the following structure:

• kind - indicates the kind of change; will be one of the following:
  • N - indicates a newly added property/element
  • D - indicates a property/element was deleted
  • E - indicates a property/element was edited
  • A - indicates a change occurred within an array
• path - the property path (from the left-hand-side root)
• lhs - the value on the left-hand-side of the comparison (undefined if kind === 'N')
• rhs - the value on the right-hand-side of the comparison (undefined if kind === 'D')
• index - when kind === 'A', indicates the array index where the change occurred
• item - when kind === 'A', contains a nested change record indicating the change that occurred at the array index

Change records are generated for all structural differences between origin and comparand. The methods only consider an object's own properties and array elements; those inherited from an object's prototype chain are not considered.

Changes to arrays are recorded simplistically. We care most about the shape of the structure; therefore we don't take the time to determine if an object moved from one slot in the array to another. Instead, we only record the structural differences. If the structural differences are applied from the comparand to the origin then the two objects will compare as "deep equal" using most isEqual implementations such as found in lodash or underscore.

Changes

When two objects differ, you can observe the differences as they are calculated and selectively apply those changes to the origin object (left-hand-side).

var observableDiff = require('deep-diff').observableDiff,
applyChange        = require('deep-diff').applyChange;

var lhs = {
	name: 'my object',
	description: 'it\'s an object!',
	details: {
		it: 'has',
		an: 'array',
		with: ['a', 'few', 'elements']
	}
};

var rhs = {
	name: 'updated object',
	description: 'it\'s an object!',
	details: {
		it: 'has',
		an: 'array',
		with: ['a', 'few', 'more', 'elements', { than: 'before' }]
	}
};

observableDiff(lhs, rhs, function (d) {
	// Apply all changes except those to the 'name' property...
	if (d.path.length !== 1 || d.path.join('.') !== 'name') {
		applyChange(lhs, rhs, d);
	}
});

API Documentation

A standard import of var diff = require('deep-diff') is assumed in all of the code examples. The import results in an object having the following public properties:

• diff - a function that calculates the differences between two objects.
• observableDiff - a function that calculates the differences between two objects and reports each to an observer function.
• applyDiff - a function that applies any structural differences from one object to another.
• applyChange - a function that applies a single change record to an origin object.