dequal

What is dequal?

The dequal npm package is a library for performing deep equality checks. It is a lightweight and fast utility for comparing objects, arrays, and other nested data structures to determine if they are equivalent in value.

What are dequal's main functionalities?

Deep equality check for objects

This feature allows you to compare two objects deeply to check if they are equal in value, regardless of whether they are different instances.

const { dequal } = require('dequal');
let obj1 = { a: 1, b: { c: 2 } };
let obj2 = { a: 1, b: { c: 2 } };
console.log(dequal(obj1, obj2)); // true

Deep equality check for arrays

This feature allows you to compare two arrays deeply to check if they are equal in value, including nested arrays.

const { dequal } = require('dequal');
let arr1 = [1, [2, 3]];
let arr2 = [1, [2, 3]];
console.log(dequal(arr1, arr2)); // true

Deep equality check for mixed structures

This feature allows you to compare mixed data structures like objects containing arrays or arrays containing objects to check for deep equality.

const { dequal } = require('dequal');
let mix1 = { a: [1, { b: 2 }] };
let mix2 = { a: [1, { b: 2 }] };
console.log(dequal(mix1, mix2)); // true

Other packages similar to dequal

lodash.isequal

Lodash's isEqual method is a popular utility for performing deep equality checks. It is part of the larger Lodash library, which provides a wide range of utilities for working with JavaScript data types. Compared to dequal, lodash.isequal is part of a larger bundle and may not be as lightweight if you only need the deep equality functionality.

deep-equal

The deep-equal package is another library that provides deep comparison functionality. It is similar to dequal in that it focuses on deep equality checks, but it may have different performance characteristics and API design.

fast-deep-equal

fast-deep-equal is a package that claims to be the fastest deep equality checker. It is similar to dequal in its purpose but may have different implementation details that could affect performance and compatibility in various use cases.

README

dequal

A tiny (247B) utility to check for deep equality

This module supports comparison of all types, including Function, RegExp, Date, null, undefined, and NaN values.
Objects and Arrays are traversed recursively.

Please note that key order within Objects does not matter.
However, the value order within Arrays does matter.

This module exposes three module definitions:

• CommonJS: dist/dequal.js
• ESModule: dist/dequal.mjs
• UMD: dist/dequal.min.js

Install

$ npm install --save dequal

Usage

const dequal = require('dequal');

dequal(1, 1); //=> true
dequal({}, {}); //=> true
dequal('foo', 'foo'); //=> true
dequal([1, 2, 3], [1, 2, 3]); //=> true
dequal(dequal, dequal); //=> true
dequal(/foo/, /foo/); //=> true
dequal(null, null); //=> true
dequal(NaN, NaN); //=> true
dequal([], []); //=> true
dequal(
  [{ a:1 }, [{ b:{ c:[1] } }]],
  [{ a:1 }, [{ b:{ c:[1] } }]]
); //=> true

dequal(1, '1'); //=> false
dequal(null, undefined); //=> false
dequal({ a:1, b:[2,3] }, { a:1, b:[2,5] }); //=> false
dequal(/foo/i, /bar/g); //=> false

API

dequal(foo, bar)

Returns: Boolean

Both foo and bar can be of any type.
A Boolean is returned indicating if the two were deeply equal.

Benchmarks

Running Node v10.13.0

fast-deep-equal   x 214,365 ops/sec ±0.30% (93 runs sampled)
dequal            x 160,116 ops/sec ±0.29% (93 runs sampled)
lodash.isEqual    x  45,257 ops/sec ±0.26% (95 runs sampled)

^{Candidates operate identically to one another}

License

MIT © Luke Edwards