Benchmark: Lodash.isEqual vs JSON.stringify Equality Comparison for markup object ver2.

HTML Preparation code:

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

Script Preparation code:

window.foo = {
          "type": "concat",
          "children": [
            {
              "type": "concat",
              "children": [
                {
                  "type": "bold",
                  "content": {
                    "type": "text",
                    "content": "Lorem ipsum dolor sit amet"
                  }
                },
                {
                  "type": "text",
                  "content": " "
                }
              ]
            },
            {
              "type": "url",
              "url": "https://ya.ru",
              "content": {
                "type": "italics",
                "content": {
                  "type": "text",
                  "content": ", consectetur adipiscing"
                }
              }
            }
          ]
        };
window.bar = {
          "type": "concat",
          "children": [
            {
              "type": "concat",
              "children": [
                {
                  "type": "bold",
                  "content": {
                    "type": "text",
                    "content": "Lorem ipsum dolor sit amet"
                  }
                },
                {
                  "type": "text",
                  "content": " "
                }
              ]
            },
            {
              "type": "url",
              "url": "https://ya.ru",
              "content": {
                "type": "italics",
                "content": {
                  "type": "text",
                  "content": ", consectetur adipiscing"
                }
              }
            }
          ]
        };

Tests:

_.isEqual
_.isEqual(window.foo, window.bar)
JSON.stringify
JSON.stringify(window.foo) === JSON.stringify(window.bar);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual
JSON.stringify

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 10 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The goal of this specific benchmark is to compare the performance of `_.isEqual` (a function from the Lodash library) with the built-in equality comparison using `JSON.stringify`.

**Benchmark Definition JSON**

The benchmark definition JSON contains two test cases:

1. `_.isEqual(window.foo, window.bar)`
	* This test case measures the performance of the `_isEqual` function from the Lodash library when comparing two objects: `window.foo` and `window.bar`.
2. `JSON.stringify(window.foo) === JSON.stringify(window.bar)`
	* This test case measures the performance of the built-in equality comparison using `JSON.stringify` when comparing two objects: `window.foo` and `window.bar`.

**Options Compared**

Two options are compared:

1. **Lodash's `_isEqual` function**: A popular utility function for deep object equality checks.
2. **Built-in `JSON.stringify` equality comparison**: A simple, built-in way to compare the string representation of two objects.

**Pros and Cons of Each Approach**

* **Lodash's `_isEqual` function**:
	+ Pros:
		- Deep object equality check
		- Can handle complex data structures (e.g., nested arrays, objects)
		- Often used in production code for its reliability and performance
	+ Cons:
		- Adds overhead due to the library's functionality and parsing
		- May have slower performance compared to built-in string comparison
* **Built-in `JSON.stringify` equality comparison**:
	+ Pros:
		- Fast and lightweight
		- Built-in, so no additional dependencies or overhead
	+ Cons:
		- Only compares the top-level properties of objects (not nested)
		- May not work as expected for complex data structures

**Library and Purpose**

* `Lodash` is a popular JavaScript utility library that provides various functions for tasks like array manipulation, string manipulation, and object manipulation. `_isEqual` is one of its most commonly used functions.

**Special JS Features/Syntax**

None mentioned in the benchmark definition JSON.

**Other Alternatives**

If you need to compare the equality of two objects with more complex data structures or performance-critical scenarios, consider using:

1. `DeepEqual` from the `fast-deep-equal` library
2. `Object.is` (ES6+)

These alternatives offer similar functionality to Lodash's `_isEqual`, but might be more lightweight or optimized for specific use cases.

**Benchmark Results**

The latest benchmark results show that `JSON.stringify` equality comparison is faster than using Lodash's `_isEqual` function, with a significant performance difference.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.77 YaBrowser/20.11.0.918 Yowser/2.5 Safari/537.36

Browser/OS: Yandex Browser 20 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
_.isEqual	114773.5 Ops/sec
JSON.stringify	161215.6 Ops/sec

Related benchmarks:

Lodash.isEqual vs JSON.stringify Equality Comparison for markup object ver2. (version: 0)

Test on isEqual performance

Comparing performance of: _.isEqual vs JSON.stringify

Created: 3 years ago by: Guest

Jump to the latest result

_.isEqual

JSON.stringify

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 10 days ago):