Benchmark: for vs foreach vs for..of vs for..of over entries vs for in 2

Script Preparation code:

var array = Array.from({length: 100});
var t;

Tests:

for
for (let i = 0,n=array.length; i < n; i++) { t = array[i]; }
foreach
array.forEach(function(v, i) { t = v; });
for..of
for (var v of array) { t = v; }
for..of over entries
for (var [,v] of array.entries()) { t = v; }
for..in
for (var k in array) { t = array[k]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
foreach
for..of
for..of over entries
for..in

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 27 days ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of various looping constructs in JavaScript by measuring how many times each loop can execute within a certain timeframe. The key constructs being compared are:

1. **for loop**
2. **forEach method**
3. **for..of loop**
4. **for..of loop over entries**
5. **for..in loop**

## Loop Constructs Explained:

### 1. **for loop**
```javascript
for (let i = 0, n = array.length; i < n; i++) {
  t = array[i];
}
```
- **Description**: This is the traditional for loop syntax. It initializes a counter (`i`), checks if it’s less than the length of the array (`n`), and increments `i` each iteration.
- **Pros**: This method is highly performant because it directly accesses array elements using their indices.
- **Cons**: It can be less readable compared to other constructs and requires manual management of the iteration variable.

### 2. **forEach method**
```javascript
array.forEach(function(v, i) {
  t = v;
});
```
- **Description**: The `forEach` method is a built-in function that iterates over each element of the array, executing the provided function for each element.
- **Pros**: It’s easier to read and write, making the code more expressive. It also eliminates the need for manually managing indices.
- **Cons**: Performance may be slower than traditional loops as it introduces a function call for each iteration, which can add overhead.

### 3. **for..of loop**
```javascript
for (var v of array) {
  t = v;
}
```
- **Description**: The `for..of` loop iterates over iterable objects like arrays, strings, or collections, directly accessing the value of each element.
- **Pros**: It provides better readability and clarity, and handles various types of iterable objects.
- **Cons**: There can be a minor performance cost compared to the traditional for loop, but it often balances out with its readability.

### 4. **for..of loop over entries**
```javascript
for (var [, v] of array.entries()) {
  t = v;
}
```
- **Description**: This uses the `entries` method, which returns an iterator of key/value pairs for each element in the array. The destructuring syntax (`[, v]`) retrieves just the value, ignoring the index.
- **Pros**: Similar to `for..of`, it enhances readability and can be useful when both keys and values are needed.
- **Cons**: The use of `.entries()` adds overhead due to creating the iterator and destructuring the values, making it generally slower than the simpler `for..of`.

### 5. **for..in loop**
```javascript
for (var k in array) {
  t = array[k];
}
```
- **Description**: The `for..in` loop iterates over the enumerable keys of an object (or array).
- **Pros**: It can be useful for looping over object properties.
- **Cons**: It is not recommended for array iteration because it can include properties from the prototype chain and iterate in an unpredictable order, leading to potential issues.

## Performance Results
According to the benchmark results you provided, the `forEach` loop performed the best with approximately 56,736 executions per second, followed closely by the `for..of` loop. The simple `for` loop came in last, performing significantly slower compared to other alternatives.

### Summary of Performance:
- **Best**: `forEach`
- **Good**: `for..of`, `for..of over entries`
- **Moderate**: `for`
- **Slowest**: `for..in`

## Alternatives
In addition to the mentioned constructs, other alternatives such as the `map`, `filter`, and `reduce` methods for specific use cases can enhance readability and expressiveness further, albeit often at a potential performance cost due to their callback nature.

In conclusion, the choice of loop construct can depend on various factors, including readability, performance needs, and specific use cases. Developers should assess which method aligns best with their requirements, considering the pros and cons of each approach.

Latest run results:

Run details: (Test run date: 27 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Linux

View result in a separate tab

Test name	Executions per second
for	8424328.0 Ops/sec
foreach	7805745.5 Ops/sec
for..of	2149981.8 Ops/sec
for..of over entries	1562206.8 Ops/sec
for..in	485361.1 Ops/sec

Related benchmarks:

for vs foreach vs for..of vs for..of over entries vs for in 2 (version: 0)

Compare loop performance

Comparing performance of: for vs foreach vs for..of vs for..of over entries vs for..in

Created: 28 days ago by: Guest

Jump to the latest result

for

foreach

for..of

for..of over entries

for..in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 27 days ago):