Benchmark: VJ _.isEqual benchmark with JSON.stringify

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

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
_.isEqual(window.foo, window.foo2);
fast deep equals similar
_.isEqual(window.foo, window.fox);
fast deep equals different
_.isEqual(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 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
fast deep equals same	2985.9 Ops/sec
fast deep equals similar	4093.3 Ops/sec
fast deep equals different	2434661.8 Ops/sec
stringify same	482.1 Ops/sec
stringify similar	516.7 Ops/sec
stringify different	533.6 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark definition and options compared, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark measures the performance of JavaScript's `_.isEqual` function (part of the Lodash library) for comparing objects, arrays, and JSON strings. The test cases cover different scenarios:

1. Deep equality checking between two identical arrays (`fast deep equals same`)
2. Deep equality checking between two similar arrays (`fast deep equals similar`)
3. Deep equality checking between two different arrays (`fast deep equals different`)
4. Stringification of an array to ensure it can be reconstructed using `JSON.stringify` and compared with another stringified version (`stringify same`, `stringify similar`, `stringify different`)

**Options Compared**

The benchmark compares the performance of three options:

1. **_.isEqual**: The Lodash library's deep equality checking function.
2. **Direct Comparison**: A simple, non-optimized comparison between two objects or arrays using the `===` operator.

**Pros and Cons**

**_.isEqual (Lodash)**

Pros:

* Designed for efficient and accurate deep equality checking
* Handles complex object structures and nested arrays
* Optimized for performance

Cons:

* May incur a slight overhead due to the use of a dedicated function
* Requires the Lodash library, which may add dependencies

**Direct Comparison**

Pros:

* Fast and lightweight, as it only requires basic arithmetic operations
* No dependencies or overhead from an external library

Cons:

* Inaccurate for complex object structures or nested arrays (e.g., comparing objects with different property orders)
* May be slower than _.isEqual due to the need for explicit comparison logic

**Other Considerations**

* The benchmark uses a desktop Linux environment, which may impact results. Mobile or web environments might yield different performance characteristics.
* The Lodash library is optimized for performance and provides a stable API for deep equality checking. Using a custom implementation or a different library might incur additional overhead.
* The test cases cover various scenarios, but it's essential to consider edge cases, such as handling null or undefined values, or comparing objects with different data types.

Overall, the benchmark demonstrates the performance advantages of using _.isEqual (Lodash) for deep equality checking compared to direct comparison. However, depending on the specific use case and requirements, a custom implementation or alternative library might be suitable.

Related benchmarks:

VJ _.isEqual benchmark with JSON.stringify (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: one year ago by: Guest

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