Benchmark: fast Deep Equal vs JSON.stringify Equality Comparison for very large arrays of nested numbers

Script Preparation code:

'use strict';

// do not edit .js files directly - edit src/index.jst


var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';


window.fdeq = function equal(a, b) {
    if (a === b) return true;

    if (a && b && typeof a == 'object' && typeof b == 'object') {
        if (a.constructor !== b.constructor) return false;

        var length, i, keys;
        if (Array.isArray(a)) {
            length = a.length;
            if (length != b.length) return false;
            for (i = length; i-- !== 0;)
                if (!equal(a[i], b[i])) return false;
            return true;
        }


        if ((a instanceof Map) && (b instanceof Map)) {
            if (a.size !== b.size) return false;
            for (i of a.entries())
                if (!b.has(i[0])) return false;
            for (i of a.entries())
                if (!equal(i[1], b.get(i[0]))) return false;
            return true;
        }

        if ((a instanceof Set) && (b instanceof Set)) {
            if (a.size !== b.size) return false;
            for (i of a.entries())
                if (!b.has(i[0])) return false;
            return true;
        }

        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
            length = a.length;
            if (length != b.length) return false;
            for (i = length; i-- !== 0;)
                if (a[i] !== b[i]) return false;
            return true;
        }


        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

        keys = Object.keys(a);
        length = keys.length;
        if (length !== Object.keys(b).length) return false;

        for (i = length; i-- !== 0;)
            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

        for (i = length; i-- !== 0;) {
            var key = keys[i];

            if (!equal(a[key], b[key])) return false;
        }

        return true;
    }

    // true if both NaN, false otherwise
    return a !== a && b !== b;
};

window.foo = Array.from({
    length: 40000
}, () => ([Math.random() * 40, Math.random() * 40]));
window.foo2 = JSON.parse(JSON.stringify(window.foo.slice()));
window.fox = (Array.from({
    length: 10000
}, () => ([Math.random() * 40, Math.random() * 40]))).concat(JSON.parse(JSON.stringify(window.foo.slice(-30000))));
window.bar = Array.from({
    length: 40000
}, () => ([Math.random() * 40, Math.random() * 40]));

Tests:

fast deep equals same
fdeq(window.foo, window.foo2);
fast deep equals similar
fdeq(window.foo, window.fox);
fast deep equals different
fdeq(window.foo, window.bar);
stringify same
JSON.stringify(window.foo) === JSON.stringify(window.foo2)
stringify similar
JSON.stringify(window.foo) === JSON.stringify(window.fox)
stringify different
JSON.stringify(window.foo) === JSON.stringify(window.bar)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
fast deep equals same
fast deep equals similar
fast deep equals different
stringify same
stringify similar
stringify different

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/118.0

Browser/OS: Firefox 118 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
fast deep equals same	981.9 Ops/sec
fast deep equals similar	1285.7 Ops/sec
fast deep equals different	5290017.5 Ops/sec
stringify same	61.0 Ops/sec
stringify similar	64.2 Ops/sec
stringify different	64.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of different approaches for comparing arrays with nested numbers, as well as stringification comparisons.

**Options Compared**

There are four options compared:

1. `fdeq(window.foo, window.foo2);` - uses a custom implementation of deep equality checking (`fdeq`) on two identical arrays (`window.foo` and `window.foo2`)
2. `fdeq(window.foo, window.fox);` - uses the same custom implementation of deep equality checking as above, but on two similar arrays (one with some elements removed)
3. `fdeq(window.foo, window.bar);` - uses the same custom implementation of deep equality checking as above, but on two different arrays
4. `JSON.stringify(window.foo) === JSON.stringify(window.foo2);` - uses a simple stringification comparison between two identical arrays
5. `JSON.stringify(window.foo) === JSON.stringify(window.fox);` - uses a similar stringification comparison as above, but on two similar arrays
6. `JSON.stringify(window.foo) === JSON.stringify(window.bar);` - uses the same stringification comparison as above, but on two different arrays

**Custom Deep Equality Checking (`fdeq`)**

The custom implementation of deep equality checking is likely a combination of the following steps:

1. Compare the lengths of the two arrays
2. Iterate through each element in the arrays
3. For each element, recursively compare the types and values of the corresponding elements in both arrays (if they are objects or arrays)
4. If any difference is found, return false

This implementation allows for a flexible comparison of nested arrays with arbitrary structures.

**Stringification Comparison**

The stringification comparison uses `JSON.stringify` to convert each array into a JSON string. Two arrays are considered equal if their JSON strings match exactly.

**Benchmark Results**

The benchmark results show the number of executions per second (ExecutionsPerSecond) for each test case on a Firefox 118 browser on a Mac OS X 10.15 device. The results suggest that:

* Deep equality checking (`fdeq`) is significantly faster than stringification comparison
* Comparing identical arrays is generally faster than comparing similar or different arrays
* Removing elements from one of the arrays in the `fdeq` tests does not significantly impact performance

Related benchmarks:

fast Deep Equal vs JSON.stringify Equality Comparison for very large arrays of nested numbers (version: 1)

Test on deep equality checking performance

Comparing performance of: fast deep equals same vs fast deep equals similar vs fast deep equals different vs stringify same vs stringify similar vs stringify different

Created: 2 years ago by: Registered User

Jump to the latest result

fast deep equals same

fast deep equals similar

fast deep equals different

stringify same

stringify similar

stringify different

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):