Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Iterator vs Index for loop
(version: 0)
Comparing performance of:
Iterator for loop vs Index for loop
Created:
3 years ago
by:
Registered User
Go to the latest result
Script Preparation code:
var arr = []; for(let i = 0; i < 10000; i++) { arr.push(Math.random()); }
Tests:
Iterator for loop
let sum = 0; for(const num of arr) { sum += num; }
Index for loop
let sum = 0; for(let i = 0; i < arr.length; i++) { sum += arr[i]; }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Iterator for loop
Index for loop
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
7 months ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0
Browser/OS:
Firefox 146 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=622887" width="100%" height="500px"></iframe>
Index for loop
36K/s
Iterator for loop
12K/s
View exact numbers
Test name
Executions per second
✓
Index for loop
35,900 Ops/sec
Iterator for loop
11,642 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. **Benchmark Overview** The benchmark compares two approaches to iterating over an array: using an iterator (`for...of` loop) versus using traditional indexing (`for...in` or `forEach` loop) with array indices. **Script Preparation Code** The script preparation code creates an empty array `arr` and populates it with 10,000 random numbers. This is a simple setup to test the iteration mechanisms. **Html Preparation Code** Since this is a JavaScript microbenchmark, there's no HTML preparation code. The benchmark only focuses on comparing the execution times of different iteration methods in JavaScript. **Library Usage** There isn't any explicit library usage mentioned in the provided code. However, some modern browsers and Node.js versions might use polyfills or built-in libraries for `for...of` loops, which could affect the results. Nevertheless, the benchmark focuses on the intrinsic differences between these two iteration methods. **Special JavaScript Features or Syntax** The benchmark uses the following special features: 1. **For-of loop**: Introduced in ECMAScript 2015 (ES6), this loop allows you to iterate over arrays, objects, and iterables using a more concise syntax. 2. **Traditional indexing**: Also part of ES6, traditional indexing allows you to access array elements by their index using square brackets (`arr[i]`). 3. **forEach**: Introduced in ECMAScript 2009 (ES5), `forEach` is a built-in method for iterating over arrays. **Comparison and Considerations** The benchmark compares the performance of two approaches: 1. **Iterator for loop**: Uses the `for...of` loop to iterate over the array, which is generally considered more readable and efficient than traditional indexing. 2. **Index for loop**: Uses traditional indexing with `forEach` (or a similar construct) to access and iterate over array elements. **Pros and Cons** **Iterator for Loop:** Pros: * More concise and readable syntax * Can be more memory-efficient, as it avoids creating additional arrays or objects * Less prone to errors due to its explicit nature Cons: * May not work with all types of iterables (e.g., sets, maps) * Performance might vary depending on the browser or engine implementation **Index for Loop:** Pros: * Well-established and widely supported syntax * Can be more predictable and easier to understand for those familiar with traditional indexing Cons: * More verbose and less readable than `for...of` * May create additional memory allocations or objects during iteration **Other Alternatives** Some alternative approaches that could be tested in a benchmark include: 1. **Array.prototype.forEach()**: This method provides an efficient way to iterate over arrays without exposing the underlying array data. 2. **Typed Array Iteration**: For performance-critical applications, using typed arrays (e.g., `Uint8Array`, `Float64Array`) can provide faster iteration times due to their compact memory representation. 3. **Generator Functions or Iterators**: These provide an alternative way to define iterators and loops, which might offer better performance or readability in certain scenarios. Keep in mind that the choice of iteration method depends on the specific use case and requirements. The benchmark provides a valuable comparison between two widely used approaches, but exploring other alternatives can help developers make informed decisions about their coding choices.
Related benchmarks
Iterator vs Index for loop (cached array length fixed)
Comments
Confirm delete:
Do you really want to delete benchmark?