Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Caching length property vs getting it each time in the loop 22
(version: 0)
save length of the array in the variable vs get it the loop
Comparing performance of:
Cache length vs Do not cache vs forEach
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var arr = []; var count = 1000; for(var i = 0; i<count; i++) { arr.push(i); }
Tests:
Cache length
var arrLen = arr.length; var sum = 0; for (var i = 0; i < arrLen; i++){ sum += arr[i]; }
Do not cache
var sum = 0; for (var i = 0; i < arr.length; i++){ sum += arr[i]; }
forEach
var sum = 0; arr.forEach(item => { sum += item })
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
Cache length
Do not cache
forEach
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/119.0.0.0 Safari/537.36
Browser/OS:
Chrome 119 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=488608" width="100%" height="500px"></iframe>
forEach
689K/s
Cache length
30K/s
Do not cache
16K/s
View exact numbers
Test name
Executions per second
✓
forEach
689,371 Ops/sec
Cache length
29,977 Ops/sec
Do not cache
15,967 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided JSON and explain what is being tested, compared options, pros and cons, and other considerations. **Benchmark Definition** The benchmark tests two approaches to iterating over an array in JavaScript: 1. **Cache length**: Saving the length of the array in a variable before the loop. 2. **Do not cache**: Not storing the length of the array beforehand, relying on the `length` property within the loop. 3. **forEach**: Using the `Array.prototype.forEach()` method to iterate over the array. **Test Case 1: Cache Length** This test case tests the performance difference between saving the array length in a variable (`var arrLen`) and not caching it (using `arr.length` directly). Pros: * Simplifies the code by removing the need for an extra variable. * Can lead to better optimization opportunities, as some JavaScript engines may be able to inline or eliminate the unnecessary assignment. Cons: * May incur additional overhead due to accessing a property on the array object repeatedly. **Test Case 2: Do Not Cache** This test case tests the performance difference between not caching the array length and using `arr.length` directly within the loop. Pros: * Avoids the need for an extra variable, potentially reducing memory allocations and garbage collection. * Can lead to better optimization opportunities, as some JavaScript engines may be able to inline or eliminate the property access. Cons: * May incur additional overhead due to repeated property accesses on the array object. **Test Case 3: forEach** This test case tests the performance of using `Array.prototype.forEach()` to iterate over an array. Pros: * Simplifies the code by eliminating the need for a manual loop. * Can lead to better optimization opportunities, as some JavaScript engines may be able to inline or eliminate the method call and iteration logic. Cons: * May incur additional overhead due to method invocation, potential memory allocations for the iterator object, and garbage collection. * Limited control over iteration parameters (e.g., index, step) compared to traditional loops. **Library Used** None explicitly mentioned in the benchmark definition. However, `Array.prototype.forEach()` is a built-in JavaScript method that relies on various libraries or engine implementations to execute. **Special JS Feature/Syntax** None explicitly mentioned. However, the use of `var` and `forEach()` might be considered non-standard in some modern JavaScript contexts (e.g., arrow functions, ES6 classes). **Other Alternatives** If you were to rewrite this benchmark using a different approach, some alternatives could include: * Using `Array.prototype.map()`, `Array.prototype.filter()`, or other array methods that provide a similar benefits as `forEach()` but with additional functionality. * Implementing a custom iterator function using a generator or iterator protocol. * Utilizing Web Workers or WebAssembly for parallel processing and iteration. Keep in mind that each alternative approach would require significant changes to the benchmark definition, preparation code, and test cases.
Related benchmarks
Caching length property vs getting it each time in the loop
Comments
Confirm delete:
Do you really want to delete benchmark?