Benchmark: Underscore vs Lodash vs Custom Vanilla JS: isEqual v2

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)
}

function compareObjects(a, b) {
 if (a === b) return true;

 if (typeof a != 'object' || typeof b != 'object' || a == null || b == null) return false;

 let keysA = Object.keys(a), keysB = Object.keys(b);

 if (keysA.length != keysB.length) return false;

 for (let key of keysA) {
   if (!keysB.includes(key)) return false;

   if (typeof a[key] === 'function' || typeof b[key] === 'function') {
     if (a[key].toString() != b[key].toString()) return false;
   } else {
     if (!compareObjects(a[key], b[key])) return false;
   }
 }

 return true;
}

Tests:

Underscore equal
underscore.isEqual(obj1, obj1copy);
Lodash equal
lodash.isEqual(obj1, obj1copy);
JSON Stringify comparison
JSON.stringify(obj1) === JSON.stringify(obj1copy)
Callback
compareObjects(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.

I'd be happy to explain the benchmark and its results.

**Benchmark Overview**

The benchmark compares the performance of three approaches: Underscore, Lodash, and a custom Vanilla JavaScript implementation, for comparing two objects with equality.

**Options Compared**

1. **Underscore's `isEqual` function**: This is a utility function that checks if two values are equal. In this case, it's used to compare two objects (`obj1` and `obj1copy`) recursively.
2. **Lodash's `isEqual` function**: Similar to Underscore's implementation, but part of the Lodash library.
3. **Custom Vanilla JavaScript implementation**: The `compareObjects` function, which is a custom implementation for comparing two objects.

**Pros and Cons**

* **Underscore's `isEqual` function**: Pros:
	+ Part of the Underscore library, so users don't need to install anything extra.
	+ Implementation is relatively simple and efficient.
Cons:
	+ Not as flexible as Lodash or custom implementation, as it doesn't allow for custom equality checks.
* **Lodash's `isEqual` function**: Pros:
	+ More comprehensive than Underscore's implementation, with more advanced features like handling functions and dates.
Cons:
	+ Requires the Lodash library to be installed, which may add extra dependencies.
* **Custom Vanilla JavaScript implementation (compareObjects)**: Pros:
	+ Highly customizable, allowing users to define their own equality checks.
	+ No external dependencies required.
Cons:
	+ Implementation is more complex and error-prone than the other two options.

**Library Usage**

The benchmark uses Lodash's `isEqual` function in one of its test cases. The `compareObjects` function is a custom implementation, not part of any library.

**Special JavaScript Features**

None mentioned in this specific benchmark, but it's worth noting that Underscore and Lodash have their own sets of features and utility functions, which can be useful for other tasks beyond equality checks.

**Other Alternatives**

If you don't want to use the custom `compareObjects` implementation, you could consider:

1. **JSON-based comparison**: Use libraries like JSON.stringify() or custom implementations like in this benchmark.
2. **Object comparison libraries**: Other libraries like Object-Inspector, deep-equal or other equality checkers can be used as alternatives.

In summary, the benchmark provides a fair comparison of three approaches for checking object equality, highlighting the pros and cons of each implementation.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0

Browser/OS: Firefox 123 on Linux

View result in a separate tab

Test name	Executions per second
Underscore equal	1276337.1 Ops/sec
Lodash equal	433497.8 Ops/sec
JSON Stringify comparison	840896.1 Ops/sec
Callback	1502108.6 Ops/sec

Related benchmarks:

Underscore vs Lodash vs Custom Vanilla JS: isEqual v2 (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: 9 months 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):