Benchmark: Loops in array and in object V2

Script Preparation code:

var _array = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
var _object = { a: 9, b: 8, c: 7, d: 6, e: 5, f: 4, g: 3, h: 2, i: 1, j: 0 };
var _preInit_objValues = Object.values(_object);

Tests:

for i++ array
let value; let len = _array.length; for (let i = 0; i < len; i++) { value = _array[i]; }
while ++i array
let value; let i = -1; let len = _array.length; while (++i < len) { value = _array[i]; }
for in array
let value; for (let i in _array) { value = _array[i]; }
for of array
let value; for (const item of _array) { value = item; }
forEach array
let value; _array.forEach((item, i, arr) => value = item);
for in object
let value; for (let p in _object) { value = _object[p]; }
for of values object
let value; const values = Object.values(_object); for (const item of values) { value = item; }
for of pre-initialized-values object
let value; for (const item of _preInit_objValues) { value = item; }
forEach pre-initialized-values object
let value; _preInit_objValues.forEach((item, i, arr) => value = item);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for i++ array
while ++i array
for in array
for of array
forEach array
for in object
for of values object
for of pre-initialized-values object
forEach pre-initialized-values object

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; rv:95.0) Gecko/20100101 Firefox/95.0

Browser/OS: Firefox 95 on Windows

View result in a separate tab

Test name	Executions per second
for i++ array	71100104.0 Ops/sec
while ++i array	56139560.0 Ops/sec
for in array	1727565.9 Ops/sec
for of array	11344216.0 Ops/sec
forEach array	14381929.0 Ops/sec
for in object	6757023.5 Ops/sec
for of values object	2972130.8 Ops/sec
for of pre-initialized-values object	10829505.0 Ops/sec
forEach pre-initialized-values object	14695355.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll do my best to break down the provided benchmarking data and explain what's being tested, compared, and their pros and cons.

**Benchmark Test Case Overview**

The test case measures performance differences between various ways of iterating over an array and an object in JavaScript. The benchmark consists of six test cases:

1. `for i++ array`
2. `while ++i array`
3. `for in array`
4. `for of array`
5. `forEach array` (using the `Array.prototype.forEach()` method)
6. `for of values object` (iterating over an array created using `Object.values()`)

**What is being tested?**

Each test case measures the performance of a specific iteration approach:

* `for i++ array`: traditional `for` loop with incrementing index
* `while ++i array`: `while` loop with incrementing index
* `for in array`: iterating over an object's own enumerable properties using the `in` keyword
* `for of array`: iterating over an array elements using the `of` keyword (introduced in ECMAScript 2019)
* `forEach array`: using the `Array.prototype.forEach()` method to iterate over an array
* `for of values object`: iterating over an array created using `Object.values()` using the `of` keyword

**Comparison**

The benchmark compares the performance of each iteration approach across multiple browser instances and platforms. The results show that:

* `for i++ array` and `forEach array` are similar in performance, but slightly faster than the other methods.
* `while ++i array` is slower than the others.
* `for of array` is significantly faster than the traditional `for` loop and `while` loop approaches.
* `for of values object` is similar to `for of array`, but with a slight penalty due to the additional step of creating an array using `Object.values()`.
* `for in array` is slower than all other methods, likely due to the overhead of checking property existence and handling prototype chains.

**Pros and Cons**

Here's a brief summary of each approach:

* `for i++ array`: simple and widely supported, but may be slower than more modern approaches.
	+ Pros: easy to implement, portable across browsers.
	+ Cons: may not leverage newer features or optimize performance as well as other methods.
* `while ++i array`: basic loop that can work, but may not be the most efficient way to iterate over arrays.
	+ Pros: straightforward implementation, works in older browsers.
	+ Cons: slower than more modern approaches, may require manual index management.
* `for of array`: a relatively new feature that provides a concise and expressive way to iterate over arrays.
	+ Pros: fast, concise, and easy to implement; widely supported in modern browsers.
	+ Cons: may not work well with older browsers or non-array data types.
* `forEach array`: using an established method for iterating over arrays is generally a good choice, especially when supporting older browsers.
	+ Pros: widely supported, reliable performance across different environments.
	+ Cons: slightly slower than the more modern `for of` methods.
* `for of values object`: creates an additional array to iterate over, which may introduce some overhead.
	+ Pros: provides a similar experience to `for of array`, but with an extra layer of indirection.
	+ Cons: slower performance compared to `for of array`, due to the array creation step.

Keep in mind that these are general observations based on this specific benchmark. The performance differences between these iteration approaches may vary depending on the specific use case and browser environment.

Related benchmarks:

Loops in array and in object V2 (version: 1)

Comparing performance of: for i++ array vs while ++i array vs for in array vs for of array vs forEach array vs for in object vs for of values object vs for of pre-initialized-values object vs forEach pre-initialized-values object

Created: 3 years ago by: Registered User

Jump to the latest result

for i++ array

while ++i array

for in array

for of array

forEach array

for in object

for of values object

for of pre-initialized-values object

forEach pre-initialized-values object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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