Benchmark: for vs forEach - MeasureThat.net

Script Preparation code:

var testArray = [];

for (var i = 1; i <= 1000; i++) {
   testArray.push(i);
}

Tests:

for loop
for(var i = 0, length = testArray.length; i < length; i += 1) { testArray[i] += 1; }
forEach
testArray.forEach((item) => { item += 1; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for loop
forEach

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and its results.

**Benchmark Definition**

The benchmark compares two approaches: `for` loops and `forEach` loops, both used to increment each element in an array of 1000 elements by 1.

**Script Preparation Code**
```javascript
var testArray = [];
```
This code creates a new JavaScript array called `testArray`, which will be used as the input for the benchmark.

**For Loop Benchmark**

The first benchmark definition is:
```javascript
for (var i = 0, length = testArray.length; i < length; i += 1) {
    testArray[i] += 1;
}
```
This is a traditional `for` loop that iterates over the elements of the array using an index variable `i`. The loop increments each element in the array by 1.

**forEach Benchmark**

The second benchmark definition is:
```javascript
testArray.forEach((item) => {
    item += 1;
});
```
This uses the `forEach` method, which executes a callback function once for each element in the array. In this case, the callback function increments each element by 1.

**Options Compared**

The two approaches being compared are:

* Traditional `for` loop with an index variable
* `forEach` loop using the built-in `forEach` method

**Pros and Cons**

**For Loop:**

Pros:

* More explicit control over iteration and indexing
* Can be faster for small to medium-sized arrays due to less overhead from the `forEach` method

Cons:

* Requires manual management of index variable, which can lead to errors if not done correctly
* Less concise and more verbose than the `forEach` approach

**forEach Loop:**

Pros:

* More concise and easier to read than traditional `for` loops
* Automatic indexing and iteration, reducing the risk of errors

Cons:

* Less control over iteration and indexing
* Can be slower for large arrays due to overhead from the `forEach` method

**Library and Special JS Features**

Neither benchmark uses any external libraries. However, it's worth noting that the `forEach` method is a built-in JavaScript method that was introduced in ECMAScript 5.

**Test Results**

The latest benchmark results show that:

* The `for` loop executed approximately 814,683 times per second on a Windows 7 device with Firefox 57.
* The `forEach` loop executed approximately 102,750.9375 times per second on the same device and browser.

These results suggest that the traditional `for` loop may be faster for this specific use case, but it's essential to note that these results might not generalize to all scenarios or devices.

**Other Alternatives**

If you're interested in exploring other alternatives, here are a few options:

* Using `Array.prototype.map()` instead of `forEach`, which would also increment each element by 1.
* Using `for...of` loops instead of traditional `for` loops with an index variable.
* Considering the use of libraries like Lodash or Ramda for array operations.

Keep in mind that these alternatives might introduce additional overhead, complexity, or performance characteristics depending on your specific use case.

Latest run results:

Run details: (Test run date: 2025 years ago)

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:57.0) Gecko/20100101 Firefox/57.0

Browser/OS: Firefox 57 on Windows 7

View result in a separate tab

Test name	Executions per second
for loop	102750.9 Ops/sec
forEach	814683.2 Ops/sec

Related benchmarks:

for vs forEach (version: 0)

Comparing performance of: for loop vs forEach

Created: 6 years ago by: Guest

Jump to the latest result

for loop

forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):