Benchmark: foreach vs map - MeasureThat.net

Script Preparation code:

var values = new Array(10000);
for (var i = 0; i < values.length; i++) values[i]=i;

Tests:

foreach
var sum = 0; values.forEach(v => sum += v );
map
var sum = 0; values.map(v => sum += v );
for of transpiled
var sum = 0; for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { var v = values_1[_i]; sum += v; }
reduce
var sum = values.reduce((s,v) => sum += v, 0);
for of
var sum = 0; for (var v of values) sum += v;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach
map
for of transpiled
reduce
for of

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll do my best to explain the JavaScript microbenchmarking results.

**Benchmark Description**

The benchmark compares four ways to iterate over an array in JavaScript:

1. `forEach`
2. `map`
3. For-of loops (transpiled and native)
4. `reduce`

**Options Compared**

Each test case uses a different iteration method to sum up the values in the `values` array.

* `forEach`: uses the `forEach` method to iterate over the array, calling a callback function for each element.
* `map`: uses the `map` method to create a new array with transformed elements, but it also iterates over the original array.
* For-of loops (transpiled and native): uses a for loop that iterates over the array using a variable (`i`) or directly on the array (`values`).
* `reduce`: uses the `reduce` method to accumulate values in an accumulator.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **forEach**:
	* Pros: concise, easy to read, and intuitive.
	* Cons: can be less efficient than other methods due to the overhead of function calls.
2. **map**:
	* Pros: creates a new array with transformed elements, which can be useful for data processing.
	* Cons: iterates over the original array twice (once for creation, once for transformation), making it less efficient.
3. **For-of loops (transpiled and native)**:
	* Pros: more control over iteration, direct access to variables, and potentially better performance.
	* Cons: can be verbose, especially for complex logic, and may require additional setup.
4. **reduce**:
	* Pros: concise, elegant, and efficient, as it only iterates over the array once.
	* Cons: requires understanding of the accumulator pattern, which can be a learning curve.

**Library Usage**

None of the test cases use any external libraries beyond standard JavaScript functionality (e.g., `Array` methods).

**Special JS Features or Syntax**

The `for-of` loops use a special syntax introduced in ECMAScript 2015 (ES6). The transpiled version is likely compiled from ES6 code to older JavaScript versions that support for-of loops. The native for-of loop uses the new iteration protocol, which is a more efficient way to iterate over arrays.

**Alternatives**

Other alternatives to these methods include:

* `while` loops: can be used as a fallback when other iteration methods are not supported.
* `Array.prototype.forEach.call()`: an older method that achieves the same result as `forEach`, but with less concise syntax.
* Custom loop implementations using `for` and manual index management.

Keep in mind that this benchmark primarily focuses on comparing different iteration methods for a specific use case (summing up values in an array). Other factors, such as performance optimization techniques or async iterations, may be more relevant in other contexts.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36 Edg/111.0.1661.44

Browser/OS: Chrome 111 on Windows

View result in a separate tab

Test name	Executions per second
foreach	11998.7 Ops/sec
map	9702.6 Ops/sec
for of transpiled	75884.6 Ops/sec
reduce	7930.9 Ops/sec
for of	5434.4 Ops/sec

Related benchmarks:

foreach vs map (version: 1)

----

Comparing performance of: foreach vs map vs for of transpiled vs reduce vs for of

Created: 7 years ago by: Registered User

Jump to the latest result

foreach

map

for of transpiled

reduce

for of

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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