Benchmark: forEach vs for...in vs for...of vs for

Script Preparation code:

var array = new Array(10000);
var bool = true;

Tests:

forEach
array.forEach(e=>{ e = 100; e++; bool = !bool; })
for..in
for (let i in array) { array[i] = 100; array[i]++; bool = !bool; }
for..of
for (let i of array) { i = 100; i++; bool = !bool; }
for
for (let i=0; i<array.length; i++) { array[i] = 100; array[i]++; bool = !bool; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for..in
for..of
for

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**What is being tested?**

The provided benchmark definition json represents a test that compares the performance of four different loop constructs: `forEach`, `for...in`, `for...of`, and `for`. Each test case uses a separate JavaScript function to iterate over an array.

**Loop options compared**

Here's a brief overview of each loop construct:

1. **`forEach`**: The `forEach` method is a built-in Array method that executes a callback function for each element in the array. It iterates over the array, and you access each element using its index (`e`).
2. **`for...in`**: The `for...in` loop is used to iterate over an object's property names. In this case, it's used to iterate over the array indices.
3. **`for...of`**: The `for...of` loop is a newer iteration of the traditional `for` loop. It's designed to work with arrays and iterates over their elements using the `value` expression.
4. **`for`**: The traditional `for` loop uses an explicit counter variable (`i`) and a condition to determine when to exit the loop.

**Pros and cons of each approach**

Here are some pros and cons for each loop construct:

1. **`forEach`**:
	* Pros: concise, easy to read, and maintain.
	* Cons: can be slower due to the overhead of calling an array method.
2. **`for...in`**:
	* Pros: works with objects as well as arrays, allowing for more flexibility.
	* Cons: doesn't work with arrays by default; you need to use `Object.keys()` or `Array.prototype.forEach.call()`.
3. **`for...of`**:
	* Pros: designed specifically for iterating over arrays, making it faster and more efficient.
	* Cons: only supports arrays; if you try to use it with an object, it will throw an error.
4. **`for`**:
	* Pros: traditional, well-understood, and works with both arrays and objects.
	* Cons: can be verbose and harder to read.

**Library used**

There is no library explicitly mentioned in the provided code snippets, but the `Array.prototype.forEach()` method is used in one of the test cases. This is a built-in JavaScript method that allows you to execute a callback function for each element in an array.

**Special JS feature or syntax**

One special feature used here is the "raw UA string" format, which represents a User Agent (UA) string. In this case, it's used to identify the browser and device being used to run the benchmark.

The `for...of` loop also uses the new iteration syntax introduced in ECMAScript 2015 (ES6).

**Other alternatives**

If you were to compare these loop constructs in a different way or with additional variations, here are some alternative approaches:

* Use an array of arbitrary values instead of just incrementing a value.
* Introduce more complex logic within the loop body, such as nested loops or conditionals.
* Compare performance using different timing functions, such as `Performance.now()` or `Date.now()`.
* Test performance under different conditions, like varying array sizes or with concurrent execution.

In summary, this benchmark compares the performance of four different loop constructs in JavaScript: `forEach`, `for...in`, `for...of`, and traditional `for`. Each construct has its pros and cons, and understanding these can help you choose the best approach for your specific use cases.

Related benchmarks:

forEach vs for...in vs for...of vs for (version: 0)

Compare loop performance

Comparing performance of: forEach vs for..in vs for..of vs for

Created: 3 years ago by: Guest

Jump to the latest result

forEach

for..in

for..of

for

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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