Benchmark: Array looping - for, Array.forEach, for-of, array.entries() - V2

Script Preparation code:

var arr = [];
var res = [];

for( var cpt = 0; cpt < 1000; cpt++ ) {
  arr.push(Math.random());
}

Tests:

Simple for loop - Access index and value
res = []; const len = arr.length; for(let i = 0; i < len; ++i) { res[i] = arr[i]; } console.log(res);
Array.forEach - Access index and value
res = []; arr.forEach((value, i) => { res[i] = value; }); console.log(res);
for-of + Array.entries
res = []; for(const [i, value] of arr.entries()) { res[i] = value; } console.log(res);
for-of - Access value only
res = []; for(const value of arr) { res.push(value); } console.log(res);
Simple for loop - Access value only
res = []; const len = arr.length; for(let i = 0; i < len; ++i) { res.push(arr[i]); } console.log(res);
Array.forEach - Access value only
res = []; arr.forEach((value) => { res.push(value); }); console.log(res);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Simple for loop - Access index and value
Array.forEach - Access index and value
for-of + Array.entries
for-of - Access value only
Simple for loop - Access value only
Array.forEach - Access value only

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark data.

**Benchmark Overview**

The benchmark measures the performance of different JavaScript looping constructs when populating an array with random values. The loops access elements using their index and value, or just the value, to compare performance differences.

**Looping Constructs Compared**

1. **Simple for loop - Access index and value**: Iterates over the array using a traditional `for` loop, accessing both the index and value of each element.
2. **Array.forEach - Access index and value**: Uses the `forEach` method to iterate over the array, providing access to both the index and value of each element.
3. **for-of + Array.entries**: Combines the `for-of` loop with `Array.entries()` to iterate over the array's entries (i.e., both its indices and values).
4. **for-of - Access value only**: Uses the `for-of` loop, but only accesses the value of each element.
5. **Simple for loop - Access value only**: Similar to the previous one, but still uses a traditional `for` loop.

**Pros and Cons**

1. **Simple for loops (Access index and value)**:
	* Pros: More control over iteration; potentially more efficient due to direct access to elements.
	* Cons: May require manual management of indices, leading to potential errors.
2. **Array.forEach**:
	* Pros: Elegant syntax; less prone to indexing errors.
	* Cons: May be slower due to the overhead of method calls and possibly less control over iteration.
3. **for-of + Array.entries**:
	* Pros: Simplifies iteration by providing both indices and values in a single loop; potentially more efficient than traditional for loops.
	* Cons: May have performance overhead due to creating an iterator object.
4. **for-of - Access value only**:
	* Pros: Convenient syntax; still provides access to elements without manual indexing.
	* Cons: Limited control over iteration, which might affect performance.

**Library and Special JS Features**

The benchmark uses the `Array.prototype.forEach` method, a built-in JavaScript library function that provides an easy way to iterate over arrays. The `for-of` loop is also a standard JavaScript feature introduced in ECMAScript 2015 (ES6).

**Other Considerations**

* **Performance**: The benchmark measures the number of executions per second for each looping construct, providing insight into their relative performance.
* **Control and Readability**: The choice between looping constructs depends on trade-offs between control, readability, and potential performance.

**Alternatives**

For similar benchmarks or alternative JavaScript features, consider:

1. ECMAScript 2017 (ES7) additions like `at` and `entries`
2. Other iteration methods like `map`, `filter`, and `reduce`
3. WebAssembly for low-level performance comparisons

Please note that benchmarking results may vary depending on the specific test environment and JavaScript engine being used.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36

Browser/OS: Chrome 127 on Linux

View result in a separate tab

Test name	Executions per second
Simple for loop - Access index and value	6558.4 Ops/sec
Array.forEach - Access index and value	7637.5 Ops/sec
for-of + Array.entries	7443.6 Ops/sec
for-of - Access value only	7589.1 Ops/sec
Simple for loop - Access value only	6326.6 Ops/sec
Array.forEach - Access value only	7339.7 Ops/sec

Related benchmarks:

Array looping - for, Array.forEach, for-of, array.entries() - V2 (version: 0)

Comparing performance of: Simple for loop - Access index and value vs Array.forEach - Access index and value vs for-of + Array.entries vs for-of - Access value only vs Simple for loop - Access value only vs Array.forEach - Access value only

Created: 4 months ago by: Guest

Jump to the latest result

Simple for loop - Access index and value

Array.forEach - Access index and value

for-of + Array.entries

for-of - Access value only

Simple for loop - Access value only

Array.forEach - Access value only

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):