Toggle navigation
MeasureThat.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
void 0 and undefined in deep call stack
(version: 0)
Check performance degradation due to scope chain when undefined is called from deep stack
Comparing performance of:
compare window.undefined and void 0 vs compare window.undefined and window.undefined
Created:
2 years ago
by:
Guest
Jump to the latest result
Tests:
compare window.undefined and void 0
function compare(n= 1e6){ for(let i = 0; i < n; i++){ undefined === void 0; } } function deep(num){ if (num === 0) { compare(); return; } else { deep(num-1); } } deep(100);
compare window.undefined and window.undefined
function compare(n= 1e6){ for(let i = 0; i < n; i++){ undefined === undefined; } } function deep(num){ if (num === 0) { compare(); return; } else { deep(num-1); } } deep(100);
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
compare window.undefined and void 0
compare window.undefined and window.undefined
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Browser/OS:
Chrome 120 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=500351" width="100%" height="500px"></iframe>
Test name
Executions per second
compare window.undefined and void 0
19.2 Ops/sec
compare window.undefined and window.undefined
9.5 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
I'll break down the provided benchmark JSON and test cases to help explain what's being tested. **Benchmark Overview** The MeasureThat.net website allows users to create and run JavaScript microbenchmarks, which is essentially a way to measure the performance of small pieces of code. In this case, we have two benchmark definitions that test different scenarios: 1. `function compare(n= 1e6){...}`: This function loops `n` times (where `n` is 1 million) and checks if `undefined` is equal to `void 0`. The purpose of this benchmark is likely to assess the performance impact of using `undefined` vs. `void 0` equality checks. 2. `function deep(num){...}`: This function recursively calls itself with decreasing values of `num` until it reaches 0. It also calls the `compare` function within its own scope. The purpose of this benchmark is to test performance degradation due to scope chain when `undefined` is called from a deep stack. **Options Compared** In both benchmarks, we're comparing two different approaches: 1. `undefined === void 0`: This checks if `undefined` is equal to `void 0`, which is equivalent in JavaScript. 2. `undefined === undefined`: This checks if `undefined` is equal to itself. The pros and cons of these approaches are as follows: * Using `undefined === void 0`: + Pros: This approach may be more efficient since `void 0` is a keyword that explicitly indicates an uninitialized or null value. + Cons: It's less intuitive for some developers, especially those from older JavaScript versions. * Using `undefined === undefined`: + Pros: This approach is more explicit and easier to understand, as it clearly states the intention of comparing `undefined` with itself. + Cons: It might be slightly slower since `undefined` needs to be dereferenced. **Library and Special JS Feature** In both benchmarks, we're using a custom-written script. There are no external libraries or special JavaScript features being tested here. **Other Considerations** When testing performance in JavaScript, it's essential to consider factors like: * Loop unrolling: Some modern JavaScript engines optimize loop unrolling, which can impact benchmark results. * Dead code elimination: Modern engines may eliminate dead code to reduce overhead. This might affect our benchmarks. * Optimizations: Different browsers and JavaScript versions might implement optimizations that affect performance. **Alternative Benchmarks** If you wanted to create alternative benchmarks for these scenarios: 1. You could test the difference between `undefined` vs. a custom variable (e.g., `const foo = void 0;`) instead of using `void 0`. 2. To assess the impact of scope chain on performance, you might create a benchmark that recursively calls itself within a larger scope and measures the degradation. Keep in mind that each benchmark is unique, and results may vary depending on the specific test case and JavaScript environment used.
Related benchmarks:
void 0 and undefined in deep call stack - 2
void 0 and undefined in deep call stack - 3
void 0 and undefined in deep call stack - 4
void 0 and undefined in deep call stack - 5
Comments
Confirm delete:
Do you really want to delete benchmark?