Benchmark: for vs foreach vs some vs for..of vs for with length

Script Preparation code:

var array = new Array(1000);

Tests:

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]; });
for..of
for (var i of array) { array[i]; }
for with length
var length = array.length; for (var i = 0; i < length; i++) { array[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
foreach
some
for..of
for with length

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The benchmark measures the performance of different loop constructs in JavaScript: `for`, `foreach`, `some`, and `for..of`. The test also includes a variation with manual length checking (`for with length`).

**Options Compared**

1. **For Loop**: This is a traditional, index-based loop that iterates over an array using the `length` property.
2. **Foreach Loop**: This is a more modern, callback-based loop that iterates over an array using the `forEach()` method.
3. **Some Method**: This method returns `true` if at least one element in the array passes the test implemented by the provided function.
4. **For..of Loop**: This is a newer, more concise way of iterating over arrays using the `for...of` loop syntax.

**Pros and Cons**

1. **For Loop**:
	* Pros: Simple, widely supported, and easy to understand.
	* Cons: Less efficient than other options, as it requires indexing into the array.
2. **Foreach Loop**:
	* Pros: More modern, concise, and easier to read. It also allows for early returns and more flexible callback functions.
	* Cons: Requires a `forEach()` method implementation, which can be slower than traditional loops.
3. **Some Method**:
	* Pros: Efficient for arrays with a single matching element, as it only requires a single pass through the array.
	* Cons: May not work as expected if multiple elements match, and requires a separate callback function.
4. **For..of Loop**:
	* Pros: Concise, modern, and easier to read. It also provides better support for iterators and generators.
	* Cons: Less flexible than traditional loops, as it only allows iterating over arrays.

**Library and Syntax**

The `forEach()` method is a built-in JavaScript method that applies a provided function to each element in an array. The syntax is:
```javascript
array.forEach(callbackFunction);
```
In the benchmark, the `foreach` loop uses this method implementation.

There are no special JS features or syntax used in this benchmark.

**Alternatives**

Other alternatives for iterating over arrays include:

1. **Array.prototype.reduce()**: This method applies a provided function to each element of an array and reduces it to a single value.
2. **Array.prototype.map()**: This method creates a new array with the results of applying a provided function to each element of the original array.
3. **Iterators**: JavaScript provides iterators, which allow you to iterate over arrays using custom logic.

Keep in mind that these alternatives may not provide performance comparable to the traditional `for` loop, but they offer more flexibility and functional programming capabilities.

I hope this explanation helps!

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36

Browser/OS: Chrome 115 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for	15553.9 Ops/sec
foreach	932026.6 Ops/sec
some	459213.5 Ops/sec
for..of	25523.2 Ops/sec
for with length	31141.3 Ops/sec

Related benchmarks:

for vs foreach vs some vs for..of vs for with length (version: 0)

Compare loop performance

Comparing performance of: for vs foreach vs some vs for..of vs for with length

Created: 4 years ago by: Guest

Jump to the latest result

for

foreach

some

for..of

for with length

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):