Benchmark: Underscore vs Lodash isEqual vs JSON.stringify with sorting

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'
        }
    }
};

Tests:

Underscore equal
underscore.isEqual(obj1, obj1copy);
Lodash equal
lodash.isEqual(obj1, obj1copy);
JSON Stringify with presorting comparison
function SortedJSONstringify(a) { const keySet = new Set(); JSON.stringify(a, (key, value) => (keySet.add(key), value)); const sortedKeys = Array.from(keySet).sort(); return JSON.stringify(a, sortedKeys); } SortedJSONstringify(obj1) === SortedJSONstringify(obj1copy)
JSON Stringify comparison
JSON.stringify(obj1) === JSON.stringify(obj1copy)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Underscore equal
Lodash equal
JSON Stringify with presorting comparison
JSON Stringify comparison

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Underscore equal	1708183.1 Ops/sec
Lodash equal	966382.3 Ops/sec
JSON Stringify with presorting comparison	369283.4 Ops/sec
JSON Stringify comparison	1377886.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is being tested on this provided JSON.

**Benchmark Description**

The benchmark compares three different approaches to check if two objects are equal:

1. **Underscore.js**: A lightweight JavaScript utility library that provides functional programming helpers, including `isEqual` function.
2. **Lodash.js**: Another popular JavaScript utility library that provides a comprehensive set of functions for various tasks, including equality checks with `isEqual` function.
3. **JSON Stringify with Presorting Comparison**: This approach uses the `JSON.stringify` method to serialize both objects and then compares the resulting strings.

**Options Compared**

The three options are compared in terms of their execution speed. The benchmark measures how many times each option executes per second.

**Pros and Cons of Each Approach**

1. **Underscore.js:isEqual**
	* Pros:
		+ Simple and lightweight, making it suitable for smaller codebases.
		+ Provides a fast equality check.
	* Cons:
		+ Limited functionality compared to other libraries like Lodash.
2. **Lodash.js:isEqual**
	* Pros:
		+ More comprehensive set of utility functions, including equality checks.
		+ Often used in larger applications due to its popularity and extensive documentation.
	* Cons:
		+ Larger file size and more dependencies compared to Underscore.js.
3. **JSON Stringify with Presorting Comparison**
	* Pros:
		+ Simple implementation that leverages the existing `JSON.stringify` method.
		+ Can be faster for large objects due to its parallel processing capabilities.
	* Cons:
		+ Requires sorting the keys of both objects, which can be slower for very large or deeply nested objects.

**Library Descriptions**

**Special JS Feature/Syntax**

None mentioned in the provided benchmark JSON.

**Other Considerations**

When choosing between these approaches, consider the following factors:

* Codebase size and complexity: For smaller codebases, Underscore.js might be a good choice. For larger applications, Lodash.js might be more suitable.
* Performance requirements: If you need to check equality for large or deeply nested objects, JSON Stringify with Presorting Comparison might be faster.

**Alternatives**

If you're looking for alternative libraries or approaches, consider:

1. **JSON Schema**: A lightweight library that provides a simple way to validate data against a schema.
2. **DeepEqual**: A fast and accurate equality check function specifically designed for deep object comparisons.
3. **Custom implementation**: Depending on your specific requirements, implementing a custom equality check function using `JSON.stringify` or other methods might be more efficient than relying on external libraries.

Keep in mind that the choice of library or approach ultimately depends on your project's specific needs and constraints.

Related benchmarks:

Underscore vs Lodash isEqual vs JSON.stringify with sorting (version: 0)

Compare Underscore vs Lodash isEqual vs JSON.stringify: Which is faster?

Comparing performance of: Underscore equal vs Lodash equal vs JSON Stringify with presorting comparison vs JSON Stringify comparison

Created: 3 years ago by: Guest

Jump to the latest result

Underscore equal

Lodash equal

JSON Stringify with presorting comparison

JSON Stringify comparison

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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