Benchmark: for vs for in vs for each vs for of

Tests:

for
const arr = [1,2,3,4,5,6,7,8,9,10]; for (var i = 0; i < arr.length; i++){ var number = arr[i]; }
for of
const arr = [1,2,3,4,5,6,7,8,9,10]; for (var n of arr){ var number = n; }
for in
const arr = [1,2,3,4,5,6,7,8,9,10]; for (var i in arr){ var number = arr[i]; }
forEach
const arr = [1,2,3,4,5,6,7,8,9,10]; arr.forEach(n => { var number = n; });
for 2
const arr = [1,2,3,4,5,6,7,8,9,10]; for (var i = 0, n = arr.length; i < n; i++){ var number = arr[i]; }
while with shift
const arr = [1,2,3,4,5,6,7,8,9,10]; while(arr.length) { var number = arr.shift(); }
while
const arr = [1,2,3,4,5,6,7,8,9,10]; var i = 0; var n = arr.length; while(i < n) { var number = arr[i]; ++i; }
while with length reduction
const arr = [1,2,3,4,5,6,7,8,9,10]; var len = arr.length; while (len--) { var number = arr[len]; }
for reverse
const arr = [1,2,3,4,5,6,7,8,9,10]; for (var i = arr.length; i >= 0; --i){ var number = arr[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
for of
for in
forEach
for 2
while with shift
while
while with length reduction
for reverse

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 127 on Windows

View result in a separate tab

while

27.3M/s

forEach

25.7M/s

for 2

25.6M/s

for reverse

23.2M/s

for of

22.8M/s

while with length reduction

20.2M/s

for

19.3M/s

while with shift

2.0M/s

for in

817K/s

View exact numbers

Test name	Executions per second
✓ while	27,336,246 Ops/sec
forEach	25,731,544 Ops/sec
for 2	25,599,286 Ops/sec
for reverse	23,216,702 Ops/sec
for of	22,831,210 Ops/sec
while with length reduction	20,193,752 Ops/sec
for	19,339,656 Ops/sec
while with shift	2,010,042 Ops/sec
for in	816,928 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares the performance of six different loop constructs: `for`, `for in`, `for each` (also known as `forEach`), `for 2`, `while with shift`, and `while`. The test case uses an array of numbers to demonstrate the difference between these loops.

**Options being compared**

Here's a brief description of each option:

1. **For**: This is a traditional loop construct that iterates over an array using an index variable.
2. **For in**: This loop constructs iterate over the properties of an object (in this case, the array). It uses the property name as the iteration variable.
3. **For each` (forEach): This loop construct iterates over an array using a closure, where the callback function receives the current element and its index.
4. **For 2**: This is a variation of the traditional `for` loop that initializes the index variable twice, once before and once inside the loop.
5. **While with shift**: This loop constructs use a while loop and remove elements from the array using `shift()` to iterate over it.
6. **For in`: This loop construct iterates over the properties of an object (in this case, the array). It uses the property name as the iteration variable.

**Performance Comparison**

The benchmark measures the number of executions per second for each loop construct on a desktop system running Chrome 127. The results show that:

* `For` and `For in` are the slowest loops, likely due to the overhead of accessing array elements using indices or property names.
* `For each` (forEach) is relatively fast, as it uses a closure to iterate over the array, which is optimized by modern JavaScript engines.
* `For 2` is slightly faster than traditional `for`, but still slower than `forEach`.
* `While with shift` is surprisingly slow, likely due to the overhead of removing elements from the array using `shift()`.
* `While with length reduction` is significantly faster than the other loops, as it avoids the overhead of accessing array elements and uses a simpler iteration logic.

**Conclusion**

This benchmark highlights the importance of choosing the right loop construct for your specific use case. `For each` (forEach) is often the best choice when you need to iterate over an array, while traditional `for` or `while with shift` might be better suited for other scenarios. The results also demonstrate the performance benefits of avoiding unnecessary overhead and using optimized iteration logic.

for vs for in vs for each vs for of (version: 7)

Comparing performance of: `for vs for of vs for in vs forEach vs for 2 vs while with shift vs while vs while with length reduction vs for reverse`

Created: 6 years ago by: Registered User

Go to the latest result

for

for of

for in

forEach

for 2

while with shift

while

while with length reduction

for reverse

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

for vs for in vs for each vs for of (version: 7)

Comparing performance of: for vs for of vs for in vs forEach vs for 2 vs while with shift vs while vs while with length reduction vs for reverse

Created: 6 years ago by: Registered User

Go to the latest result

for

for of

for in

forEach

for 2

while with shift

while

while with length reduction

for reverse

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `for vs for of vs for in vs forEach vs for 2 vs while with shift vs while vs while with length reduction vs for reverse`