Benchmark: for-vs-foreach-vs-forof

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(someFn);
for
for (var i = 0, len = arr.length; i < len; i++) { someFn(arr[i]); }
for of
for(xxx of arr){ someFn(xxx); }
arrowForEach
arr.forEach((item)=>{ someFn(item); });
forBackward
for (var i=arr.length-1; i>=0; i--) { someFn(arr[i]); }
reverse while
var i = arr.length; while (i--) { someFn(arr[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for
for of
arrowForEach
forBackward
reverse while

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmark that compares the performance of four different loop constructs in JavaScript:

1. `forEach`
2. `for` (traditional)
3. `for...of` (newer iteration syntax)
4. `arrowForEach` (a variation of `forEach` with arrow functions)

**What is tested?**

The benchmark measures the execution speed of each loop construct when iterating over an array of 1000 elements, performing a simple multiplication operation (`someFn(i) = i * 3 * 8`) on each element. The benchmark is executed on different browsers and devices to gather performance data.

**Options compared**

Here's a brief overview of each option:

1. **`forEach`**: Iterates over the array using the `forEach` method, which calls the callback function once for each element.
	* Pros: Easy to read and maintain, concise syntax.
	* Cons: May incur additional overhead due to method call, potential performance impact if array is large or complex.
2. **`for` (traditional)**: Iterates over the array using a traditional `for` loop with an index variable (`i`).
	* Pros: Well-established, efficient for simple iteration patterns.
	* Cons: Can be verbose and less readable than newer syntaxes.
3. **`for...of`**: Iterates over the array using the newer `for...of` loop syntax, which allows iterating directly on arrays and other iterable objects.
	* Pros: More concise and expressive than traditional `for`, efficient for simple iteration patterns.
	* Cons: Less well-known and less supported by older browsers.
4. **`arrowForEach`**: A variation of `forEach` that uses arrow functions to simplify the callback syntax.
	* Pros: Concise and readable, potentially easier to maintain than traditional `forEach`.
	* Cons: May incur additional overhead due to function creation, potential performance impact if array is large or complex.

**Library usage**

None of the options listed require a specific library; they are built-in JavaScript features.

**Special JS feature or syntax**

The benchmark uses newer syntaxes like `for...of` and arrow functions (`=>`) in some cases. These features are not essential to understanding the benchmark, but knowing their basics can help with interpreting the results.

**Other considerations**

* The benchmark only measures the execution speed of each loop construct; other factors like memory usage or code readability might be relevant for larger projects.
* The use of a fixed array size (1000 elements) might not represent real-world scenarios, where array sizes can vary greatly.
* The benchmark is executed on different browsers and devices to gather diverse performance data.

**Alternatives**

If you're looking for alternative benchmarks or microbenchmarking tools, some popular options include:

1. Benchmark.js: A lightweight JavaScript library specifically designed for benchmarking.
2. MathJS: A math-focused benchmarking tool that can be used for general-purpose benchmarking.
3. JSPerf: A web-based benchmarking platform that allows running and comparing JavaScript benchmarks.

Keep in mind that the choice of benchmarking tool or library depends on your specific needs, such as ease of use, performance characteristics, or additional features like support for parallel execution.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36

Browser/OS: Chrome 63 on Windows 7

View result in a separate tab

Test name	Executions per second
forEach	57075.6 Ops/sec
for	2920.4 Ops/sec
for of	1039.2 Ops/sec
arrowForEach	3916.8 Ops/sec
forBackward	3238.7 Ops/sec
reverse while	3709.2 Ops/sec

Related benchmarks:

for-vs-foreach-vs-forof (version: 0)

Comparing performance of: forEach vs for vs for of vs arrowForEach vs forBackward vs reverse while

Created: 6 years ago by: Guest

Jump to the latest result

forEach

for

for of

arrowForEach

forBackward

reverse while

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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