Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
typeof undefined vs undefined equality check vs double-equal
(version: 0)
Comparing performance of:
equality vs typeof vs double-equal
Created:
5 years ago
by:
Guest
Go to the latest result
Script Preparation code:
window.obj = undefined
Tests:
equality
window.obj === undefined
typeof
typeof window.obj === 'undefined'
double-equal
window.obj == undefined
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
equality
typeof
double-equal
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0
Browser/OS:
Firefox 115 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=523647" width="100%" height="500px"></iframe>
double-equal
5.6M/s
typeof
5.6M/s
equality
5.6M/s
View exact numbers
Test name
Executions per second
✓
double-equal
5,638,272 Ops/sec
typeof
5,586,318 Ops/sec
equality
5,584,100 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons. **Benchmark Overview** The test is designed to compare three approaches for checking if `window.obj` is `undefined`: 1. Equality check (`===`) 2. `typeof` operator with `'undefined'` 3. Double-equal operator (`==`) **Library and Special JS Features** In this benchmark, the only library being used is the built-in JavaScript language features. No special JavaScript features or syntax are being tested in this benchmark. **Approaches Compared** 1. **Equality Check (`===`)** * This is a simple and straightforward way to check if two values are equal. * Pros: + Easy to understand and implement. + Wide browser support. * Cons: + Can be slow due to the type coercion involved in `===`. 2. **`typeof` Operator with `'undefined'`** * This checks the type of a variable using the `typeof` operator, comparing it to `'undefined'`. * Pros: + Fast and efficient. * Cons: + May not work as expected if the variable is an object or has a custom constructor. 3. **Double-Equal Operator (`==`)** * This checks if two values are "loose equal" (i.e., they have the same value, but not necessarily the same type). * Pros: + Simple and easy to use. * Cons: + Can lead to unexpected behavior due to type coercion. **Results** The benchmark results show the number of executions per second for each test case on Firefox 115. The order of execution speed is: 1. `typeof` Operator with `'undefined'` 2. Equality Check (`===`) 3. Double-Equal Operator (`==`) This suggests that the `typeof` operator with `'undefined'` is the fastest approach, followed closely by the equality check. **Alternatives** If you need to optimize this type of comparison, consider the following alternatives: 1. Use a dedicated equality function (e.g., `isEqual`) that can be optimized for performance. 2. Implement a custom equality check using bitwise operations or other tricks to avoid type coercion. 3. Consider using a more modern JavaScript feature, such as the `===` operator with strict equality (`strictEqual`) which is faster than the traditional equality check. Keep in mind that these alternatives may require additional expertise and may not be necessary for most use cases. The original approach of using `typeof` or equality checks will likely suffice for most applications.
Related benchmarks
typeof undefined vs undefined equality check
Typeof x === 'undefined' vs x === undefined (test without syntax error)
Comments
Confirm delete:
Do you really want to delete benchmark?