Benchmark: for var vs foreach vs map

Script Preparation code:

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

Tests:

foreach
arr.forEach(function (item){ someFn(item); })
for
for (let item of arr) { someFn(item); }
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 dive into the world of JavaScript microbenchmarks!

**What is being tested?**

The provided JSON represents a benchmark that tests three different approaches to iterate over an array in JavaScript:

1. `for` loop with a traditional variable (`var i`)
2. `forEach` loop, which is a built-in method for iterating over arrays
3. `map` function, which returns a new array with the results of applying a provided function to each element

**Options compared**

The benchmark compares the performance of these three approaches on an array of 1000 elements.

**Pros and Cons of each approach:**

1. **Traditional `for` loop (`var i`)**:
	* Pros: Simple, easy to understand, and works in older browsers.
	* Cons: Can lead to issues with variable scope and naming conflicts.
2. **`forEach` loop**:
	* Pros: Easy to read and maintain, built-in method, and works well in most modern browsers.
	* Cons: May have performance overhead due to the V8 engine's optimization of `forEach` calls.
3. **`map` function**:
	* Pros: Concise and expressive, returns a new array with transformed elements, and is widely supported.
	* Cons: Creates a new array, which can lead to memory allocation and deallocation overhead.

**Library usage**

In this benchmark, the `forEach` loop uses the built-in `forEach` method of arrays, which is part of the ECMAScript standard. No additional libraries are required.

**Special JS feature or syntax**

There are no special JavaScript features or syntax used in this benchmark. The code only relies on standard ECMAScript constructs.

**Benchmark results**

The latest benchmark result shows that:

* `for` loop with a traditional variable (`var i`) performs the best, with approximately 33631 executions per second.
* `forEach` loop has slightly worse performance, around 29541 executions per second.
* `map` function has the worst performance, with approximately 26712 executions per second.

**Other alternatives**

If you're looking for alternative approaches to iterate over arrays in JavaScript, consider:

1. **`reduce()` method**: Another built-in array method that can be used for iteration, although it's less straightforward than `forEach`.
2. **Manual indexing**: Using manual indexing (`arr[i]`) or pointer arithmetic (`arr[i++]`) as an alternative to the traditional `for` loop.
3. **Generator functions**: Using generator functions with `yield` to create a custom iterator.

However, these alternatives might not be as efficient or readable as the three approaches tested in this benchmark.

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
foreach	29541.8 Ops/sec
for	33632.0 Ops/sec
map	26712.2 Ops/sec

Related benchmarks:

for var vs foreach vs map (version: 0)

Comparing performance of: foreach vs for vs map

Created: one year 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):