Benchmark: Lodash vs Native JS isEqual

HTML Preparation code:

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

Script Preparation code:

function isEqual(x, y) {
  const ok = Object.keys, tx = typeof x, ty = typeof y;
  return x && y && tx === 'object' && tx === ty ? (
    ok(x).length === ok(y).length &&
      ok(x).every(key => isEqual(x[key], y[key]))
  ) : (x === y);
}

// 1 level deep
window.foo1 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar1 = { a: 1, b: 3, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };

// 2 levels deep
window.foo2 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar2 = { a: 1, b: 2, c: { a: 1, b: 3, c: { a: 1, b: 2 } } };

// 3 levels deep
window.foo3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 4 } } };

Tests:

Lodash lvl 1
_.isEqual(window.foo1, window.bar1)
Native lvl 1
isEqual(window.foo1, window.bar1)
Lodash lvl 2
_.isEqual(window.foo2, window.bar2)
Native lvl 2
isEqual(window.foo2, window.bar2)
Lodash lvl 3
_.isEqual(window.foo3, window.bar3)
Native lvl 3
isEqual(window.foo3, window.bar3)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash lvl 1
Native lvl 1
Lodash lvl 2
Native lvl 2
Lodash lvl 3
Native lvl 3

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

**Benchmark Definition JSON**

The benchmark definition defines two types of equality checks:

1. **Lodash**: A JavaScript library that provides various utility functions, including `isEqual`, which checks if two values are equal.
2. **Native JS**: The built-in JavaScript equality check, implemented using the `==` or `===` operators.

**Options Compared**

The benchmark compares the performance of these two approaches on three levels of nested objects:

* Level 1: Two simple objects with one property each (`foo1` and `bar1`)
* Level 2: Two objects with two properties each, including another object as a value (`foo2` and `bar2`)
* Level 3: Three levels deep, where the innermost object has four properties (`foo3` and `bar3`)

**Pros and Cons of Different Approaches**

1. **Lodash (isEqual)**:
	* Pros:
		+ More robust and flexible equality check, handling complex nested structures.
		+ Can be used for more than just equality checks, as it's a utility library.
	* Cons:
		+ Slower due to the overhead of the Lodash library.
2. **Native JS**:
	* Pros:
		+ Faster, as it uses the built-in JavaScript operators.
	* Cons:
		+ May not handle all edge cases or complex nested structures correctly.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides various functions for tasks such as array manipulation, string formatting, and object comparison. In this benchmark, Lodash's `isEqual` function is used to compare the equality of two values.

**Special JS Feature/Syntax: Object Properties**

The benchmark tests how the equality check handles nested objects with multiple properties. This involves traversing the object property graph to determine if all properties are equal.

In the context of this benchmark, both Lodash and Native JS handle nested objects correctly by recursively comparing their properties. However, Lodash provides more robust handling of complex cases, such as when one object has a specific number of properties that the other does not have.

**Alternatives**

Other alternatives to compare in a benchmark for equality checks could include:

* Other utility libraries like `lodash-es`, `ramda`, or `underscore`
* Built-in JavaScript methods like `JSON.stringify` and `JSON.parse`
* Custom-written implementations using recursive functions or object property iteration

Keep in mind that the choice of alternative depends on the specific requirements and constraints of the benchmark.

Latest run results:

Run details: (Test run date: 6 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36

Browser/OS: Chrome 123 on Android

View result in a separate tab

Test name	Executions per second
Lodash lvl 1	726290.6 Ops/sec
Native lvl 1	763460.4 Ops/sec
Lodash lvl 2	494978.0 Ops/sec
Native lvl 2	441474.9 Ops/sec
Lodash lvl 3	377674.7 Ops/sec
Native lvl 3	318526.8 Ops/sec

Related benchmarks:

Lodash vs Native JS isEqual (version: 0)

Comparing performance of: Lodash lvl 1 vs Native lvl 1 vs Lodash lvl 2 vs Native lvl 2 vs Lodash lvl 3 vs Native lvl 3

Created: 6 months ago by: Registered User

Jump to the latest result

Lodash lvl 1

Native lvl 1

Lodash lvl 2

Native lvl 2

Lodash lvl 3

Native lvl 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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