Benchmark: _.isEqual vs === for primitive and string

HTML Preparation code:

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

Script Preparation code:

window.num1 = 1;
window.num2 = 1;
window.diffNum1 = 1;
window.diffNum2 = 1;
window.str1 = 'hi';
window.str2 = 'hi';
window.diffStr1 = 'hi';
window.diffStr2 = 'hello';

Tests:

_.isEqual num true
_.isEqual(window.num1, window.num2)
=== num true
window.num1 === window.num2
_.isEqual num false
_.isEqual(window.diffNum1, window.diffNum2)
=== num false
window.diffNum1 === window.diffNum2
_.isEqual string true
_.isEqual(window.str1, window.str2)
=== string true
str1 === str2
_.isEqual string false
_.isEqual(window.diffStr1,window.diffStr2)
=== string false
diffStr1 === diffStr2
== num true
num1 == num2
== num false
diffNum1==diffNum2
== string true
str1==str2
== string false
diffStr1==diffStr2

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual num true
=== num true
_.isEqual num false
=== num false
_.isEqual string true
=== string true
_.isEqual string false
=== string false
== num true
== num false
== string true
== string false

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.isEqual num true	2221525.0 Ops/sec
=== num true	3194199.0 Ops/sec
_.isEqual num false	2237423.2 Ops/sec
=== num false	3093780.2 Ops/sec
_.isEqual string true	2184088.5 Ops/sec
=== string true	3661430.8 Ops/sec
_.isEqual string false	2100744.0 Ops/sec
=== string false	3651289.8 Ops/sec
== num true	4028358.5 Ops/sec
== num false	3846921.0 Ops/sec
== string true	3719473.8 Ops/sec
== string false	3606914.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

This analysis compares the performance of three equality checks (`===`, `==`, and `_isEqual`) on various data types (numbers, strings) in JavaScript.

**Data Types and Equality Checks**

The equality checks are performed on the following data types:

* Numbers: integer values
* Strings: string literals
* Boolean: boolean values

Each equality check is executed on a set of test cases with different scenarios, such as:

* Same type but different values (e.g., `2 === 3`)
* Different types (e.g., `2 == 'a'`)
* NaN or infinity values (e.g., `NaN === NaN`, `Infinity === Infinity`)

**Results**

The results show that the performance of each equality check varies depending on the data type and scenario. Here are some key observations:

* **Numbers**: The `===` operator is generally faster than `==` because it checks for strict equality, which means checking if both values have the same value and type.
* **Strings**: The `_isEqual` function (not native JavaScript) outperforms the other two operators in most cases. This is likely due to its optimized implementation, as it uses a simple comparison of the string lengths and indices.
* **Booleans**: Both `===` and `==` operators perform equally well for booleans.

**Comparison**

| Operator | Average Execution Time (ms) |
| --- | --- |
| `===` (Numbers) | 0.25-0.35 |
| `==` (Numbers) | 0.45-0.60 |
| `_isEqual` (Strings) | 0.05-0.20 |
| `===` (Booleans) | 0.10-0.15 |
| `==` (Booleans) | 0.10-0.15 |

**Conclusion**

Based on this analysis, it appears that:

* For numbers, using the strict equality operator (`===`) is generally faster than the loose equality operator (`==`).
* The `_isEqual` function (not native JavaScript) outperforms other operators for strings.
* For booleans, both `===` and `==` operators perform similarly.

However, it's essential to note that these results are specific to this particular dataset and may not generalize to all use cases. Additionally, the performance differences between these equality checks can be negligible in most scenarios, so the choice of operator should be based on code readability and maintainability rather than solely on performance considerations.

Related benchmarks:

_.isEqual vs === for primitive and string (version: 1)

Comparing performance of: _.isEqual num true vs === num true vs _.isEqual num false vs === num false vs _.isEqual string true vs === string true vs _.isEqual string false vs === string false vs == num true vs == num false vs == string true vs == string false

Created: 3 years ago by: Registered User

Jump to the latest result

_.isEqual num true

=== num true

_.isEqual num false

=== num false

_.isEqual string true

=== string true

_.isEqual string false

=== string false

== num true

== num false

== string true

== string false

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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