Benchmark: Array loop vs foreach vs map (10k)

Script Preparation code:

   var arr = [];
    for (var i = 0; i < 10000; i++) {
      arr[i] = i;
    }
  
    function someFn(i) {
      return i * 3 * 8;
    }

Tests:

foreach
arr.forEach(function (item){ someFn(item); })
for
for (var i = 0, len = arr.length; i < len; i++) { someFn(arr[i]); }
map
arr.map(item => someFn(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

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is being tested.

**Benchmark Definition**

The benchmark defines three test cases:

1. `foreach`: Uses the `forEach` method to iterate over an array, calling the `someFn` function on each element.
2. `for`: Uses a traditional `for` loop to iterate over an array, calling the `someFn` function on each element.
3. `map`: Uses the `map` method to create a new array with transformed elements, calling the `someFn` function on each element.

**Script Preparation Code**

The script preparation code creates an array of 10,000 elements and defines a simple function `someFn` that takes an integer `i` as input and returns `i * 3 * 8`.

**Html Preparation Code**

There is no HTML preparation code provided.

**Options Compared**

The benchmark compares the performance of three different approaches:

* **`forEach`**: Uses the `forEach` method to iterate over an array.
* **`for` loop**: Uses a traditional `for` loop to iterate over an array.
* **`map`**: Uses the `map` method to create a new array with transformed elements.

**Pros and Cons**

Here are some pros and cons of each approach:

* **`forEach`**:
	+ Pros: Easy to use, concise syntax, works well for small arrays.
	+ Cons: Can be slower than traditional loops due to the overhead of the `forEach` method.
* **`for` loop**:
	+ Pros: Fastest execution time, good control over iteration variables.
	+ Cons: More verbose syntax, can be error-prone if not used correctly.
* **`map`**:
	+ Pros: Concise syntax, creates a new array with transformed elements, efficient for large datasets.
	+ Cons: Can be slower than traditional loops due to the overhead of creating a new array.

**Library and Purpose**

The `forEach`, `for`, and `map` methods are built-in JavaScript methods. They provide an alternative way to iterate over arrays or create new arrays with transformed elements, respectively.

**Special JS Feature or Syntax**

There is no special JS feature or syntax used in this benchmark.

**Other Alternatives**

Some other alternatives for iterating over arrays include:

* **`Array.prototype.forEach.call()`**: This method calls the `forEach` method on an array-like object.
* **`Array.prototype.reduce()`**: This method reduces an array to a single value by applying a callback function to each element.
* **`Array.prototype.filter()`**: This method creates a new array with filtered elements.

Keep in mind that these alternatives may have different performance characteristics and use cases compared to the `forEach`, `for`, and `map` methods.

Latest run results:

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

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

Browser/OS: Chrome 69 on Mac OS X 10.13.6

View result in a separate tab

Test name	Executions per second
foreach	1695.5 Ops/sec
for	1032.5 Ops/sec
map	1700.3 Ops/sec

Related benchmarks:

Array loop vs foreach vs map (10k) (version: 0)

Comparing performance of: foreach vs for vs map

Created: 6 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 28 days ago):