Benchmark: fast Deep Equal vs JSON.stringify Equality Comparison for 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: 4000}, () => ([Math.random() * 40, Math.random() * 40]));
window.foo2 = JSON.parse(JSON.stringify(window.foo.slice()));
window.fox = JSON.parse(JSON.stringify(window.foo.slice(0, 3000))).concat(Array.from({length: 1000}, () => ([Math.random() * 40, Math.random() * 40])));
window.bar = Array.from({length: 4000}, () => ([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: 7 hours ago)

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

Browser/OS: Firefox 133 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
fast deep equals same	5066.0 Ops/sec
fast deep equals similar	2552256.5 Ops/sec
fast deep equals different	2346326.0 Ops/sec
stringify same	407.6 Ops/sec
stringify similar	405.4 Ops/sec
stringify different	401.6 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark, its options, pros and cons, and other considerations.

**What is tested:**

The benchmark tests the performance of three different equality comparison approaches:

1. `fdeq(window.foo, window.foo2);`: This test checks the performance of a custom equality function (`fdeq`) implemented by the user.
2. `JSON.stringify(window.foo) === JSON.stringify(window.foo2);`: This test checks the performance of comparing two objects using their stringified representations.
3. `JSON.stringify(window.foo) === JSON.stringify(window.fox);` and `JSON.stringify(window.foo) === JSON.stringify(window.bar);`: These tests check the performance of comparing two objects with similar and different properties, respectively.

**Options:**

The benchmark provides four test cases:

* `fast deep equals same`: Compares two arrays (`window.foo` and `window.foo2`) that are identical.
* `fast deep equals similar`: Compares two arrays (`window.foo` and `window.fox`) that have some common elements but also some differences.
* `fast deep equals different`: Compares two arrays (`window.foo` and `window.bar`) that have no common elements.
* `stringify same`, `stringify similar`, and `stringify different`: These tests compare two objects using their stringified representations.

**Pros and Cons:**

The custom equality function (`fdeq`) implemented by the user likely provides a good balance between performance and accuracy. However, its performance may vary depending on the specific implementation and the size of the input arrays.

The `JSON.stringify` approach has some advantages:

* It is a well-established standard for comparing objects.
* It can handle complex object structures with ease.
* However, it may be slower than a custom equality function for large inputs due to the overhead of stringification and comparison.

On the other hand, the `JSON.stringify` approach has some disadvantages:

* It may not be suitable for very large inputs due to memory constraints.
* The resulting strings can be difficult to read and debug.

**Other considerations:**

The benchmark's results are likely influenced by various factors, such as:

* The specific browser and device used for testing (e.g., Chrome Mobile iOS 129).
* The size of the input arrays (`window.foo`, `window.foo2`, `window.fox`, and `window.bar`).
* The presence of JavaScript engines that optimize or cache equality comparisons.

To improve the benchmark's accuracy, it would be helpful to:

* Use a more representative sample of browsers and devices.
* Increase the size of the input arrays to better simulate real-world scenarios.
* Consider adding additional test cases to cover edge cases and corner cases.

Related benchmarks:

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

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):