Benchmark: javascript loops

Tests:

foreach
const items = Array.from({length: 1000}, () => Math.floor(Math.random() * 40)); let index = 0; items.forEach(i => index++);
for-in
const items = Array.from({length: 1000}, () => Math.floor(Math.random() * 40)); let index = 0; for (let i in items) { index++; }
for-of
const items = Array.from({length: 1000}, () => Math.floor(Math.random() * 40)); let index = 0; for (let i of items) { index++; }
for
const items = Array.from({length: 1000}, () => Math.floor(Math.random() * 40)); let index = 0; for(let i = 0; i < items.length; ++i) { index++; }
optimized-for
const items = Array.from({length: 1000}, () => Math.floor(Math.random() * 40)); let index = 0; for(let i = items.length; i > 0; --i) { index++; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach
for-in
for-of
for
optimized-for

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its results.

**Benchmark Definition**

The benchmark is designed to test the performance of different JavaScript loop constructs: `forEach`, `for-in`, `for-of`, and traditional `for` loops, as well as an optimized version of the `for` loop. The benchmark measures the time taken by each loop construct to iterate over a large array of random numbers.

**Options Compared**

The benchmark compares four main options:

1. **`forEach`**: This method calls a provided callback function for each element in an array, without requiring explicit index management.
2. **`for-in`**: This loop construct iterates over the properties (including indices) of an object using the `in` operator.
3. **`for-of`**: This is a newer loop construct introduced in ECMAScript 2015, which allows iterating over arrays or iterators without requiring explicit index management.
4. **Traditional `for` loop**: This classic loop construct uses a counter variable to iterate over an array.

**Pros and Cons**

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

* **`forEach`**: Pros: concise, easy to read, and maintain. Cons: can be slower due to the overhead of function calls and potentially more memory allocations.
* **`for-in`**: Pros: works on both arrays and objects. Cons: can be slower due to the overhead of accessing properties using `in`, and may not work well with arrays that have a large number of numeric indices (which are assumed to be property names).
* **`for-of`**: Pros: concise, easy to read, and maintain. Cons: requires support for modern JavaScript versions; can be slower due to the overhead of creating an iterator.
* **Traditional `for` loop**: Pros: widely supported, fast, and flexible. Cons: may require more boilerplate code.

**Optimized `for` Loop**

The optimized version of the `for` loop uses a technique called "iterative increment" instead of incrementing the counter variable using the ++ operator. This optimization can reduce the overhead of incrementing the counter variable, potentially leading to faster performance.

**Libraries and Special Features**

In this benchmark, none of the test cases use any external libraries or special JavaScript features beyond what's included in the standard ECMAScript specification.

**Other Alternatives**

For more comprehensive loop performance comparisons, consider using other benchmarks like:

* jsPerf
* Benchmark.js
* Google's Closure Compiler

These tools provide a wider range of test cases and can offer more detailed insights into the performance characteristics of different JavaScript loops.

Latest run results:

Run details: (Test run date: 3 days ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
foreach	2692.8 Ops/sec
for-in	2638.6 Ops/sec
for-of	2816.4 Ops/sec
for	2871.5 Ops/sec
optimized-for	2935.6 Ops/sec

Related benchmarks:

javascript loops (version: 1)

Comparing performance of: foreach vs for-in vs for-of vs for vs optimized-for

Created: 4 years ago by: Registered User

Jump to the latest result

foreach

for-in

for-of

for

optimized-for

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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