Benchmark: Underscore vs Lodash vs Custom Vanilla JS: isEqual

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script type="text/javascript">
  window.lodash = _;
  _ = null;
</script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.9.1/underscore-min.js'></script>
<script type="text/javascript">
  window.underscore = _;
  _ = null;
</script>

Script Preparation code:

var obj1 = {
  0: {
    1: {
      key: 'one'
  	}
  }
};

var obj1copy = {
  0: {
    1: {
      key: 'one'
  	}
  }
};

var obj2 = {
  0: {
    1: {
      key: 'two'
  	}
  }
};
function isEqual(a,b){
	return JSON.stringify(a) === JSON.stringify(b)
}

Tests:

Underscore equal
underscore.isEqual(obj1, obj1copy);
Lodash equal
lodash.isEqual(obj1, obj1copy);
JSON Stringify comparison
JSON.stringify(obj1) === JSON.stringify(obj1copy)
Callback
isEqual(obj1, obj1copy);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Underscore equal
Lodash equal
JSON Stringify comparison
Callback

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Overview**

The benchmark compares the performance of three JavaScript libraries: Underscore, Lodash, and custom vanilla JavaScript (without any external dependencies). Specifically, it measures the speed of comparing two objects using `isEqual` function in each library.

**Options Compared**

1. **Underscore**: The `isEqual` function from Underscore uses a simple recursive approach to compare the objects.
2. **Lodash**: Lodash's `isEqual` function uses a more efficient approach by checking if the two objects have the same keys and values, and then comparing their corresponding properties.
3. **Custom Vanilla JS**: This option uses a custom implementation of the `isEqual` function that checks for deep object equality using `JSON.stringify`.

**Pros and Cons**

1. **Underscore**:
	* Pros: Simple to implement, easy to understand.
	* Cons: Not optimized for performance, can lead to infinite recursion if objects have circular references.
2. **Lodash**:
	* Pros: More efficient than Underscore, handles object equality with circular references.
	* Cons: Requires external dependency (Lodash library), may not be suitable for small projects or personal use.
3. **Custom Vanilla JS**:
	* Pros: No external dependencies, can be optimized for performance, and flexible to handle custom logic.
	* Cons: Requires manual implementation of object equality logic, which can be error-prone.

**Library Descriptions**

1. **Underscore**: A lightweight utility library that provides a variety of functional programming helpers, including `isEqual`.
2. **Lodash**: A popular utility library that extends Underscore with additional functions, including `isEqual`.

**Special JS Feature/Syntax**

None mentioned in the provided benchmark definition.

**Other Alternatives**

For handling object equality comparisons, other JavaScript libraries or approaches exist, such as:

1. **JSON Schema**: Provides a robust and flexible way to validate and compare objects.
2. **DeepEqual**: A small library that implements a more efficient algorithm for comparing deep object equality.
3. **Custom implementation using Object.keys() and Array.prototype.every()`: Another approach to manually implement object comparison.

Keep in mind that the choice of library or implementation depends on specific requirements, performance needs, and personal preferences.

I hope this explanation helps!

Latest run results:

Run details: (Test run date: 7 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Underscore equal	738331.8 Ops/sec
Lodash equal	457203.8 Ops/sec
JSON Stringify comparison	593725.2 Ops/sec
Callback	651239.2 Ops/sec

Related benchmarks:

Underscore vs Lodash vs Custom Vanilla JS: isEqual (version: 0)

Compare Underscore vs Lodash isEqual. Which is faster?

Comparing performance of: Underscore equal vs Lodash equal vs JSON Stringify comparison vs Callback

Created: 3 years ago by: Guest

Jump to the latest result

Underscore equal

Lodash equal

JSON Stringify comparison

Callback

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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