Benchmark: for vs foreach vs some vs for..of vs for cached length non empty array actually check no break

Script Preparation code:

var a = new Array(10000);


for(i=0; i<5000; i++){
    a[i] = ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
}
a[5000] = 1488;
for(i=5001; 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
var has1488 = false; for (var i = 0; i < a.length; i++) { if (a[i] === 1488) has1488 = true; }
for cached length
var has1488 = false; for (var i = 0, l=a.length; i < l; ++i) { if (a[i] === 1488) has1488 = true; }
some
var has1488 = a.some(function(i) { return i === 1488; });
for..of
var has1488 = false; for (var i of a) { if (i === 1488) has1488 = true; }
foreach
var has1488 = false; a.forEach(function(i) { if (i === 1488) has1488 = true; });

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.0.0 Safari/537.36

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
for	791.2 Ops/sec
for cached length	1646.5 Ops/sec
some	37033.0 Ops/sec
for..of	96259.5 Ops/sec
foreach	15973.2 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.

**Benchmark Definition**
The provided JSON represents a benchmarking test that compares the performance of different loop constructs in JavaScript:

1. `for` (traditional loop)
2. `foreach` (using the `forEach()` method)
3. `some` (using the `some()` method)
4. `for..of` (using the `for...of` loop)

**Options Compared**

The benchmark compares the performance of these four options when iterating over an array to find a specific value.

**Pros and Cons of Each Approach:**

1. **Traditional `for` Loop**
	* Pros: Simple, efficient, and widely supported.
	* Cons: Can be verbose and error-prone, especially for large arrays or complex conditions.
2. **`foreach` (using the `forEach()` method)**
	* Pros: Easy to read and write, concise syntax.
	* Cons: May incur additional overhead due to the method call and iteration.
3. **`some` (using the `some()` method)**
	* Pros: Simple and efficient, can short-circuit as soon as the condition is met.
	* Cons: May not be suitable for all use cases, especially when searching for a specific value in an array.
4. **`for..of` Loop**
	* Pros: Easy to read and write, concise syntax, and optimized for arrays.
	* Cons: May require additional setup (e.g., declaring the loop variable) and is not as widely supported as traditional `for` loops.

**Library Usage**

None of the provided benchmark definitions use external libraries.

**Special JS Features or Syntax**

The `for..of` loop uses a new syntax introduced in ECMAScript 2015, which allows for concise iteration over arrays. The `some()` method also uses a standard JavaScript function that is widely supported.

**Other Alternatives**

Other alternatives for iterating over arrays include:

1. **`Array.prototype.every()`**: Similar to `some()`, but returns `true` if all elements match the condition.
2. **`Array.prototype.find()`**: Returns the first element that matches the condition, or `undefined` if no element matches.
3. **`while` Loop**: A traditional loop construct that can be used for array iteration.

Keep in mind that these alternatives may have different performance characteristics and use cases compared to the options tested in this benchmark.

Related benchmarks:

for vs foreach vs some vs for..of vs for cached length non empty array actually check no break (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):