Benchmark: NodeList For vs Foreach

Script Preparation code:

var div = document.createElement('div');
for (let i = 0; i < 1000; i++) {
    div.insertAdjacentHTML('beforeend', `<span>span-${i}<span>`);
}

var list = div.querySelectorAll('span');

Tests:

Default For
for(let i = 0; i < list.length; i++) { list[i].setAttribute('tabindex', '-1'); }
For with length caching
list.forEach(item =>{ item.setAttribute('tabindex', '-1'); });
forEach
for(let i = 0, lenght = list.lenght ; i < length; i++) { list[i].setAttribute('tabindex', '-1'); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Default For
For with length caching
forEach

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'll break down the benchmark and explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares the performance of three different approaches for iterating over an array:

1. **Default For Loop**: A traditional for loop that uses the `length` property to iterate over the array.
2. **For with Length Caching**: A modified for loop that uses a cached value for the `length` property, which is calculated at the beginning of each iteration.
3. **forEach**: The `forEach` method, which is a more modern and concise way of iterating over arrays.

**Options Compared**

The benchmark tests the performance of these three approaches on an array of 1000 elements. Each approach has its own set of characteristics:

* **Default For Loop**: Iterates over the array using the `length` property.
	+ Pros: Simple, widely supported, and easy to understand.
	+ Cons: Can be slower due to the repeated calculation of `length`.
* **For with Length Caching**: Uses a cached value for `length`, which is calculated at the beginning of each iteration.
	+ Pros: Reduces the overhead of calculating `length` repeatedly.
	+ Cons: May not work correctly if the cache is cleared or updated dynamically.
* **forEach**: Iterates over the array using an iterator.
	+ Pros: Concise, efficient, and modern syntax.
	+ Cons: Less control over iteration, may have additional overhead.

**Library and Features**

There are no libraries used in this benchmark. However, it's worth noting that some JavaScript implementations (e.g., V8) have specific optimizations for certain iteration methods.

**Special JS Features/Syntax**

None of the provided test cases use special JavaScript features or syntax. They rely on standard ECMAScript features and are designed to be platform-agnostic.

**Pros and Cons Summary**

| Approach | Pros | Cons |
| --- | --- | --- |
| Default For Loop | Simple, widely supported | Can be slower due to repeated `length` calculation |
| For with Length Caching | Reduces `length` overhead | May not work correctly if cache is cleared or updated dynamically |
| forEach | Concise, efficient, modern syntax | Less control over iteration, additional overhead |

**Other Considerations**

When choosing an iteration method, consider the following factors:

* **Performance**: If performance is critical, using a cached value for `length` (For with Length Caching) or exploiting iterator optimizations (forEach) may be beneficial.
* **Readability and Maintainability**: Default For Loop and forEach are often easier to read and understand, while For with Length Caching may require more attention to cache management.
* **Platform and Browser Support**: Ensure that the chosen iteration method is supported by the target platform and browser.

**Alternative Approaches**

Other iteration methods you might consider include:

* **While loops**: Can be more flexible than for loops, but may be slower due to the repeated calculation of `length`.
* **Recursive functions**: Can iterate over arrays in a concise manner, but may have performance drawbacks due to recursive function calls.
* **Array.prototype.map() and Array.prototype.filter()**: Can be used to create new arrays with transformed or filtered elements, but may not provide direct access to array elements.

Keep in mind that the optimal iteration method depends on the specific use case and requirements. The provided benchmark can help you understand the performance characteristics of each approach, but it's essential to consider additional factors when making your final decision.

Latest run results:

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

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Default For	681.6 Ops/sec
For with length caching	750.8 Ops/sec
forEach	1739086.1 Ops/sec

Related benchmarks:

NodeList For vs Foreach (version: 0)

Comparing performance of: Default For vs For with length caching vs forEach

Created: 4 years ago by: Guest

Jump to the latest result

Default For

For with length caching

forEach

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