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

Tests:

test equality
var n = 0; while(true) { n++; if(n==100000) break; }
AخA

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

Object

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

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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):

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:

== (loose equality)
=== (strict equality)
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.

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.

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