Benchmark: Which equals operator (== vs === vs Object.is) is faster?

Tests:

test equality
var n = 0; while(true) { n++; if(n==100000) break; }
test strict equality
var n = 0; while(true) { n++; if(n===100000) break; }
Object
var n = 0; while(true) { n++; if(Object.is(n,100000)) break; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
test equality
test strict equality
Object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 133 on Android

View result in a separate tab

Test name	Executions per second
test equality	22451.4 Ops/sec
test strict equality	22316.6 Ops/sec
Object	6259.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The provided JSON represents a benchmark test case that compares the performance of three different equality operators in JavaScript: `==`, `===`, and `Object.is()`. The tests are designed to measure which operator is faster for a specific use case, where a variable `n` is incremented until it reaches 100,000.

**Options compared**

There are three options being compared:

1. **`==` (loose equality)**
2. **`===` (strict equality)**
3. **`Object.is()`** (from the JavaScript built-in `Object` prototype)

Each option has its own pros and cons:

* `==` is a loose equality operator that checks for value equality, but not type equality. It can lead to unexpected behavior when comparing different data types.
* `===` is a strict equality operator that checks both value and type equality. It's generally safer than `==`, but can also be slower due to the additional type checking.
* `Object.is()` is a built-in function that performs a deep comparison of two values, including their types. It's considered more accurate than `==` or `===`, but may also be slower.

**Other considerations**

When choosing between these operators, consider the following:

* If you need to compare different data types (e.g., numbers and strings), `===` might be a better choice.
* If you're working with legacy code that uses `==`, it's essential to understand its limitations and potential issues.
* When performance is critical, profiling tools can help determine which operator is actually being used by the browser.

**Libraries and special JS features**

None of the provided test cases use any libraries or special JavaScript features. The benchmarks only rely on standard JavaScript operators and built-in functions.

**Benchmark preparation code**

The `Script Preparation Code` and `Html Preparation Code` fields are empty, which means that the benchmark doesn't require any additional setup beyond what's already included in the benchmark definition.

Overall, this benchmark test case provides a useful comparison of three equality operators in JavaScript, helping developers understand their performance characteristics and choose the best operator for specific use cases.

Related benchmarks:

Which equals operator (== vs === vs Object.is) is faster? (version: 0)

Is there a performance benefit to replacing == with ===?

Comparing performance of: test equality vs test strict equality vs Object

Created: 2 years ago by: Guest

Jump to the latest result

test equality

test strict equality

Object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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