smelukov / nano-equal

Ultra fast and compact implementation of deep equal without any production dependencies.

NanoEqual

Ultra fast and compact implementation of deep equal without any production dependencies.

Usage

npm install nano-equal --save

var nanoEqual = require('nano-equal');

if (nanoEqual(a, b)) {
    //....
}

What is that?

This is a compact and fast implementation of deep equal.

Deep equal is an algorithm that comparing two values. If the values are a scalar (string, bool, number), then comparing will be performed thru === operator.

If the values are an object (object, array, function), then comparing will be performed recursively.

Following of the object properties is not important:

var a = {prop1: 'some', prop2: 'some'};
var b = {prop2: 'some', prop1: 'some'};

nanoEqual(a, b); // true

But following of the array elements is important:

var a = [1, 2, 3];
var b = [3, 2, 1];

nanoEqual(a, b); // false

NaN values and some types of recursion are supported.

Benchmark

The list below is showing the performance comparison nano-equal with other libs:

nanoEqual: 1362.813ms
underscore: 3791.308ms
lodash: 7830.107ms
nodejs: 8272.956ms

nano-equal's Issues

cross-linked objects

Hi! Another hard example. This code leads to call stack overflow

objA = {};
objB = {};
objA.a = objB;
objB.a = objA;

https://jsbin.com/qapojupoyi/1/edit?js,console

I believe same can be done with cross-linked arrays

[bug] comparison of array to pseudo-array throws exception

equal({'0': 0, '1': 1, length: 2}, [0, 1])

https://runkit.com/esp/59457b5efa3ec10012bdf2f0

False positive when a properties within an array item is modified

node: 8.9.0
npm: 5.5.1

The scenario below produces a false positive.

const ne = require('nano-equal');
let oa = { 'a': 1, 'b': [1, { 'c': 'd' }], e: { 'a': [1, 2, '2'] } };
let ob = { 'a': 1, 'b': [1, { 'c': 'd' }], e: { 'a': [1, 2, '2'] } };

console.log(ne(oa, ob) ? 'equal' : 'not equal'); // equal
ob.b[1].d = 1
console.log(ne(oa, ob) ? 'equal' : 'not equal') // equal <- incorrect

Also the below scenario

console.log(ne(oa, ob) ? 'equal' : 'not equal'); // equal
ob.b.c = 1// this is valid js although b is an array
console.log(ne(oa, ob) ? 'equal' : 'not equal') // equal <- incorrect

Testing deep equality gist has more tests

Incorrect result for cyclic objects

The example below is expected to return true but returns false:

var nanoEqual = require("nano-equal")

const a = {aaa: 123};
a.a = a;

const b = {aaa: 123};
b.a = {aaa: 123};
b.a.a = b;

nanoEqual(a,b); // → false

[bug] valueOf / toString

Remove please brackets after Object.prototype.valueOf() and Object.prototype.toString()

        if (a.valueOf !== Object.prototype.valueOf() && b.valueOf !== Object.prototype.valueOf()) {
            return a.valueOf() === b.valueOf();
        }

        if (a.toString !== Object.prototype.toString() && b.toString !== Object.prototype.toString()) {
            return a.toString() === b.toString();
        }