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)

Historical Performance Data aggregated from 215 community runs

Desktop Results:

Chrome 174 runs

fast deep equals similar

21.7M/s

fast deep equals different

20.2M/s

fast deep equals same

9K/s

stringify similar

620/s

stringify different

618/s

stringify same

592/s

Fastest: fast deep equals similar (36671.8x faster)

View exact numbers

✓ fast deep equals similar: 21,724,084 ops/sec
• fast deep equals different: 20,218,356 ops/sec
• fast deep equals same: 8,950 ops/sec
• stringify similar: 620 ops/sec
• stringify different: 618 ops/sec
• stringify same: 592 ops/sec

Firefox 35 runs

fast deep equals similar

3.9M/s

fast deep equals different

3.8M/s

fast deep equals same

8K/s

stringify different

530/s

stringify same

529/s

stringify similar

528/s

Fastest: fast deep equals similar (7393.4x faster)

View exact numbers

✓ fast deep equals similar: 3,901,678 ops/sec
• fast deep equals different: 3,824,281 ops/sec
• fast deep equals same: 7,665 ops/sec
• stringify different: 530 ops/sec
• stringify same: 529 ops/sec
• stringify similar: 528 ops/sec

Mobile Results:

Chrome 6 runs

fast deep equals similar

3.2M/s

fast deep equals different

3.1M/s

fast deep equals same

4K/s

stringify similar

612/s

stringify different

602/s

stringify same

593/s

Fastest: fast deep equals similar (5448.2x faster)

View exact numbers

✓ fast deep equals similar: 3,230,151 ops/sec
• fast deep equals different: 3,139,500 ops/sec
• fast deep equals same: 3,503 ops/sec
• stringify similar: 612 ops/sec
• stringify different: 602 ops/sec
• stringify same: 593 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 5 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36

Browser/OS: Chrome 145 on Mac OS X 10.15.7

View result in a separate tab

fast deep equals different

29.4M/s

fast deep equals similar

29.1M/s

fast deep equals same

12K/s

stringify same

2K/s

stringify similar

710/s

stringify different

521/s

View exact numbers

Test name	Executions per second
✓ fast deep equals different	29,449,414 Ops/sec
fast deep equals similar	29,053,998 Ops/sec
fast deep equals same	11,752 Ops/sec
stringify same	1,701 Ops/sec
stringify similar	710 Ops/sec
stringify different	521 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 4 years ago by: Registered User

Go to the latest result

fast deep equals same

fast deep equals similar

fast deep equals different

stringify same

stringify similar

stringify different

Historical Performance Data aggregated from 215 community runs

Desktop Results:

Chrome 174 runs

Firefox 35 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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: 4 years ago by: Registered User

Go to the latest result

fast deep equals same

fast deep equals similar

fast deep equals different

stringify same

stringify similar

stringify different

Historical Performance Data aggregated from 215 community runs

Desktop Results:

Chrome 174 runs

Firefox 35 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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`