Benchmark: Deep equals - MeasureThat.net

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.7.8/angular.min.js"></script>

Script Preparation code:

var data = [{foo: {bar: {foo: {bar: ''}}}}, {}, {}];

Tests:

R.equals
var result = R.equals(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
_.isEqual
var result = _.isEqual(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
angular.equals
var result = angular.equals(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
JSON.stringify
var result = JSON.stringify(data) === JSON.stringify([{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
R.equals
_.isEqual
angular.equals
JSON.stringify

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is tested in each benchmark.

**Script Preparation Code**

The script preparation code defines a JavaScript object `data` that contains three nested objects, which are used as input for the benchmarks.

**Html Preparation Code**

The html preparation code includes three external libraries:

1.  Ramda: A functional programming library used for its `R.equals` function.
2.  Lodash: A utility library used for its `_isEqual` function.
3.  Angular.js: A JavaScript framework used for its `angular.equals` function.

**Benchmark Definitions**

The benchmark definitions are individual test cases that compare the equality of the input data with a specific output. There are four benchmark definitions:

1.  **R.equals**: This benchmark tests whether two objects are deeply equal using Ramda's `R.equals` function.
2.  **_isEqual**: This benchmark tests whether two objects are deeply equal using Lodash's `_isEqual` function.
3.  **angular.equals**: This benchmark tests whether two objects are deeply equal using Angular.js's `angular.equals` function.
4.  **JSON.stringify**: This benchmark tests whether the input data can be serialized to a string using `JSON.stringify` and then compared with the expected output.

**Pros and Cons of Different Approaches**

Here's a brief analysis of each approach:

*   **Deep equals functions (R.equals, _isEqual)**: These functions check for deep equality between objects. However, they may return false positives due to differences in object representation (e.g., object type or structure). On the other hand, they provide a more comprehensive comparison than simple equality checks.
*   **Angular's angular.equals**: This function is specific to Angular.js and might not work correctly with non-Angular applications. It also has limitations when dealing with nested objects.
*   **JSON.stringify**: While `JSON.stringify` can serialize an object to a string, it may not cover all edge cases (e.g., circular references or unserializable data). Additionally, this approach is less efficient than direct equality checks.

**Other Considerations**

When choosing between these approaches, consider the following factors:

*   **Precision**: If exact deep equality is required, use Ramda's `R.equals` or Lodash's `_isEqual`. Otherwise, Angular's `angular.equals` might be sufficient.
*   **Performance**: Direct equality checks are generally faster than serialization and comparison.
*   **Library dependencies**: Be aware of the libraries used (e.g., Ramda, Lodash) and potential compatibility issues.

**Alternatives**

If you're not satisfied with these approaches or need additional features, consider the following alternatives:

*   **Built-in `===` operator**: While it's not as comprehensive as deep equality checks, the built-in `===` operator can work for simple comparisons.
*   **Custom implementation**: Write a custom function to compare two objects using a specific strategy (e.g., iterating over object properties).
*   **Other libraries or frameworks**: Explore other libraries or frameworks that provide similar functionality, such as TypeScript's deep equality checks.

I hope this explanation helps you understand the provided benchmarks and choose the best approach for your needs!

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 98 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
R.equals	107258.2 Ops/sec
_.isEqual	221693.5 Ops/sec
angular.equals	638525.9 Ops/sec
JSON.stringify	463241.9 Ops/sec

Related benchmarks:

Deep equals (version: 0)

Comparing performance of: R.equals vs _.isEqual vs angular.equals vs JSON.stringify

Created: 4 years ago by: Guest

Jump to the latest result

R.equals

_.isEqual

angular.equals

JSON.stringify

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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