Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Array loop vs foreach vs map vs while
(version: 0)
Comparing performance of:
foreach vs for vs map vs while
Created:
5 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var arr = []; for (var i = 0; i < 1000000; i++) { arr[i] = i; } function someFn(i) { return i * 3 * 8; }
Tests:
foreach
arr.forEach(function (item){ someFn(item); })
for
for (var i = 0, len = arr.length; i < len; i++) { someFn(arr[i]); }
map
arr.map(item => someFn(item))
while
let i = 0, len = arr.length; while (i<len) { someFn(arr[i]); i++; }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
foreach
for
map
while
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/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15
Browser/OS:
Safari 17 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=512416" width="100%" height="500px"></iframe>
map
33/s
foreach
17/s
for
14/s
while
14/s
View exact numbers
Test name
Executions per second
✓
map
33 Ops/sec
foreach
17 Ops/sec
for
14 Ops/sec
while
14 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark definition and test cases. **Benchmark Definition:** The benchmark is designed to measure the performance of four different loop constructs in JavaScript: 1. `forEach` 2. Traditional `for` loop 3. `map` function 4. `while` loop These loops will be used to iterate over an array (`arr`) that contains 1 million elements, and perform a simple calculation on each element using the `someFn` function. **Library:** None. The benchmark uses only built-in JavaScript features and no external libraries. **Special JS Features/Syntax:** None mentioned in this specific benchmark. However, it's worth noting that some modern JavaScript versions and browsers support additional features like arrow functions (`=>`) used in the `map` test case. **Loop Constructs:** Let's analyze each loop construct: 1. **`forEach`**: This loop uses the `forEach` method to iterate over the array elements. It's a concise way to execute an action on every element in an array. * Pros: + Easy to read and write + No manual indexing required * Cons: + Can be slower than traditional loops for large arrays due to the overhead of method calls 2. **Traditional `for` loop**: This loop uses a manual index variable to iterate over the array elements. * Pros: + Fast and efficient for large arrays + Control over indexing and iteration * Cons: + More verbose and error-prone 3. **`map` function**: This loop uses the `map` method to create a new array with transformed values. * Pros: + Concise and expressive way to perform transformations on arrays + Fast for large arrays due to caching * Cons: + Creates a new array, which can be memory-intensive 4. **`while` loop**: This loop uses a manual index variable to iterate over the array elements. * Pros: + Similar performance characteristics to traditional `for` loops + Control over indexing and iteration * Cons: + More verbose and error-prone **Performance Considerations:** The performance differences between these loop constructs can be attributed to various factors: * **Overhead of method calls**: The `forEach` and `map` methods have an overhead due to the way they handle iteration and indexing. This can lead to slower performance for large arrays. * **Cache locality**: Modern CPUs optimize cache access, which is important when iterating over arrays in a sequential manner (e.g., traditional `for` loop or `while` loop). However, the caching benefits may be reduced with array methods like `map`. * **Memory allocation and deallocation**: Creating a new array using `map` can lead to increased memory allocation and deallocation, which can impact performance. **Alternatives:** If you're looking for alternative approaches, consider: * Using an iterative approach with a library like `iteratee` or implementing your own iteration function. * Using other concurrency models, such as parallel processing or worker threads, if the benchmark is designed to measure performance under heavy loads. * Optimizing the loop construct and surrounding code using compiler optimizations or specific browser flags (e.g., Safari's `-O3` flag). Please note that this analysis assumes a general understanding of JavaScript performance considerations. If you're looking for more in-depth information on these topics, feel free to ask!
Related benchmarks
Array loop: forEach vs for vs map vs for of entries
Array loop vs foreach vs map with large array
Comments
Confirm delete:
Do you really want to delete benchmark?