Benchmark: for vs foreach vs some vs for..of vs for cached length non empty array

Script Preparation code:

var a = new Array(10000);


for(i=0; i<10000; i++){
    a[i] = ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
}

Tests:

for
for (var i = 0; i < a.length; i++) { a[i]; }
for cached length
for (var i = 0, l=a.length; i < l; ++i) { a[i]; }
some
a.some(function(i) { a[i]; });
for..of
for (var i of a) { a[i]; }
foreach
a.forEach(function(i) { a[i]; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
for cached length
some
for..of
foreach

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
for	363.9 Ops/sec
for cached length	760.0 Ops/sec
some	136.3 Ops/sec
for..of	144.9 Ops/sec
foreach	146.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is used to describe the test case and its purpose. In this case, it compares the performance of four different loop constructs: `for`, `foreach`, `some`, and `for..of`. The script preparation code creates an array `a` with 10,000 elements and a custom function that generates a large random number for each element.

**Loop Constructs**

Now, let's break down each loop construct:

1. **`for`**: This is the traditional way of looping over an array in JavaScript. It uses a variable `i` to keep track of the current index, which increments by 1 on each iteration.
	* Pros: Simple and widely supported.
	* Cons: Can be slow for large arrays due to the overhead of incrementing the loop counter.
2. **`for cached length`**: This loop construct uses a variable `l` to store the length of the array, which is calculated once before the loop starts. The loop then increments `i` using the pre-calculated length.
	* Pros: Can be faster than traditional `for` loops for large arrays, as it avoids the overhead of incrementing the loop counter.
	* Cons: Requires the length of the array to be known before the loop starts, which may not always be the case.
3. **`some`**: This is a method on the `Array` prototype that returns `true` if at least one element in the array passes a test. It iterates over the array using a callback function.
	* Pros: Can be faster than traditional loops for arrays with only some elements that need to be processed.
	* Cons: May not work as expected for arrays with all elements that need to be processed, as it stops iterating once it finds a true value.
4. **`for..of`**: This is a newer loop construct introduced in ECMAScript 2015 (ES6). It uses the `for...of` keyword to iterate over an array, which provides a more concise and expressive way of looping.
	* Pros: More concise and readable than traditional loops, with better support for array iterators.
	* Cons: May not be supported by older browsers or JavaScript engines.

**Library and Special Features**

The benchmark uses the `crypto` library to generate random numbers. While not explicitly mentioned in the benchmark definition, it's worth noting that this library is used to introduce some randomness into the generated numbers.

There are no special features or syntax mentioned in the benchmark definition that require a deep understanding of JavaScript beyond what's already explained.

**Alternatives**

If you're interested in exploring alternative loop constructs, here are a few options:

* **`while` loops**: While not as concise or expressive as `for...of`, `while` loops can be useful for certain use cases where the loop condition is complex.
* **`forEach` methods**: In addition to `some`, there's also `every` and `filter` that provide different ways of iterating over arrays with predicates.
* **Array iterators**: If you're interested in exploring more advanced iteration techniques, array iterators can be used to create custom iteration mechanisms.

Overall, the benchmark provides a useful comparison of four common loop constructs in JavaScript, highlighting their strengths and weaknesses.

Related benchmarks:

for vs foreach vs some vs for..of vs for cached length non empty array (version: 0)

Compare loop performance

Comparing performance of: for vs for cached length vs some vs for..of vs foreach

Created: 3 years ago by: Guest

Jump to the latest result

for

for cached length

some

for..of

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