Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
for vs for..of vs forEach
(version: 0)
Comparing performance of:
for native vs for vs forEach vs some
Created:
5 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var array = new Array(1000);
Tests:
for native
for (var i = array.length - 1; i >= 0; i--) { array[i]; }
for
for (var i = 0; i < array.length; i++) { array[i]; }
forEach
array.forEach(function(i) { array[i]; });
some
array.some(function(i) { array[i]; });
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
for native
for
forEach
some
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; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Browser/OS:
Chrome 120 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=497538" width="100%" height="500px"></iframe>
some
475K/s
forEach
475K/s
for native
11K/s
for
6K/s
View exact numbers
Test name
Executions per second
✓
some
475,048 Ops/sec
forEach
474,956 Ops/sec
for native
11,294 Ops/sec
for
5,645 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 Definition** The benchmark is defined by a JSON object that contains information about the test: * `Name`: The name of the benchmark, which is "for vs for..of vs forEach". * `Description`: An empty string, indicating that no description is provided. * `Script Preparation Code` and `Html Preparation Code`: These fields contain JavaScript code that prepares the environment for the benchmark. In this case, a 1,000-element array is created using the `Array` constructor. **Individual Test Cases** The benchmark consists of four test cases: 1. **"for native"`**: This test uses the traditional `for` loop syntax, which iterates over an array by accessing its indices directly. 2. **"for"`**: This test also uses a traditional `for` loop syntax, but with a slightly different initialization and condition. 3. **"forEach"`**: This test uses the `forEach()` method of the `Array` object to iterate over the elements of the array. 4. **"some"`**: This test uses the `some()` method of the `Array` object, which returns `true` as soon as it finds an element that satisfies a provided condition. **Library and Special JS Features** In this benchmark, no special JavaScript libraries are used. However, some older browsers may have supported newer syntaxes or methods that aren't included in this benchmark (e.g., `for..of`, which was introduced in ECMAScript 2015). **Comparison of Options** The three options being compared are: * **Traditional `for` loop**: This is the most common way to iterate over an array in JavaScript. It's simple and straightforward but can be less efficient due to its use of implicit indexing. * **`forEach()` method**: Introduced in ECMAScript 1999, this method provides a more concise and expressive way to iterate over arrays. However, it may be slower than traditional `for` loops because it requires creating an iterator object. * **`some()` method**: Also introduced in ECMAScript 1999, this method returns as soon as it finds an element that satisfies the provided condition. It's useful for testing early exit conditions but can be less efficient overall. **Pros and Cons** Here are some pros and cons of each option: * **Traditional `for` loop**: + Pros: Simple, efficient, and widely supported. + Cons: Implicit indexing can lead to errors, and it may not be suitable for complex iterations. * **`forEach()` method**: + Pros: Concise, expressive, and easy to read. It's also a good choice when you need to perform some operation on each element. + Cons: May be slower than traditional `for` loops due to iterator object creation. * **`some()` method**: + Pros: Early exit condition, which can save processing time in certain scenarios. + Cons: Returns as soon as the condition is met, which may not provide a complete iteration. **Other Alternatives** If you want to explore other options, here are a few alternatives: * **`for..of` loop**: Introduced in ECMAScript 2015, this syntax provides a concise way to iterate over arrays and objects. * **`while` loops**: These can be used for array iterations when the length of the array is unknown or needs to be checked frequently. Keep in mind that these alternatives may have their own trade-offs and limitations.
Related benchmarks
Array fill foreach, vs for i loop
foreach vs for..of
foreach vs for...of
For loop vs <Array>.forEach() vs for...of loop
forEach vs for of 7
Comments
Confirm delete:
Do you really want to delete benchmark?