Benchmark: Array loop vs foreach vs map noFx

Script Preparation code:

 var arr = [];
 for (var i = 0; i < 10000; i++) {
	arr[i] = i;
}

Tests:

foreach
arr.forEach(item => console.log(item))
for
for (var i = 0, len = arr.length; i < len; i++) { console.log(arr[i]); }
map
arr.map(item => console.log(item))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach
for
map

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/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
foreach	9.0 Ops/sec
for	8.7 Ops/sec
map	8.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is testing three approaches to iterate over an array:

1. **Array.forEach**: Using the `forEach` method to iterate over the array, which calls a callback function for each element in the array.
2. **Traditional For Loop**: Using a traditional `for` loop with an index variable to iterate over the array elements.
3. **Array.map**: Using the `map` method to create a new array with transformed values, but since we only log the result to console without returning anything, it's more of a testing iteration rather than actual mapping.

**Options Compared**

The benchmark is comparing three different approaches:

1. **Array.forEach**
2. **Traditional For Loop** (without any modifications)
3. **Array.map**

Each approach has its own pros and cons:

* **Array.forEach**: Pros - concise, easy to read, and maintainable code; Cons - may be slower than traditional loops due to the overhead of function calls.
* **Traditional For Loop**: Pros - often faster and more efficient since it avoids the overhead of function calls; Cons - can be verbose and error-prone for large arrays or complex logic.
* **Array.map**: Pros - concise and expressive code; Cons - may not be suitable for all use cases (e.g., modifying original array), and in this benchmark, it's mostly used as a testing iteration.

**Library and Special JS Features**

In this benchmark, no libraries are explicitly mentioned. However, the `forEach` method is part of the ECMAScript standard, so it doesn't require any additional libraries to work.

No special JavaScript features or syntax are being tested in this benchmark.

**Alternative Approaches**

Other approaches that could be used for iterating over an array include:

1. **Array.prototype.every**, **Array.prototype.some**, **Array.prototype.reduce**
2. **Set iterators**
3. **Generator functions**

These alternatives have their own pros and cons, and some might perform better or worse than the three tested approaches in this benchmark.

For example:

* **Array.prototype.every** and **Array.prototype.some** can be useful for checking array elements against a condition.
* **Array.prototype.reduce** can be used to accumulate values or perform complex calculations on an array.
* **Set iterators** can be used for iterating over sets, but might not be as suitable for arrays.

Overall, the benchmark provides a good starting point for comparing the performance of different iteration approaches in JavaScript.

Related benchmarks:

Array loop vs foreach vs map noFx (version: 0)

Comparing performance of: foreach vs for vs map

Created: 4 years ago by: Guest

Jump to the latest result

foreach

for

map

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):