Benchmark: for/for each/forEach1

Script Preparation code:

var array = new Array(100);

Tests:

for
var bla = 0; for (var i = 0; i < array.length; i++) { bla++; } console.log(bla);
for each
var bla =0; for (var item in array) { bla++; } console.log(bla);
forEach
var bla=0; array.forEach(function(item, index) { bla++; }); console.log(bla);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
for each
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.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Benchmark Definition**

The benchmark definition provides an array of 100 elements, which will be used as input for the tests. The script preparation code initializes this array in memory. There is no HTML preparation code.

**Test Cases**

There are three test cases:

1. **"for"`**: This test case uses a traditional `for` loop to iterate over the array and increment a variable (`bla`) 100 times.
2. **"for each"`**: This test case uses the `in` operator with an array (not recommended in modern JavaScript) to iterate over the array and increment the same variable (`bla`) 100 times.
3. **"forEach"`**: This test case uses the `Array.prototype.forEach()` method, which is a built-in function for iterating over arrays, to execute a callback function for each element in the array and increment the same variable (`bla`).

**Options Compared**

The three test cases compare the performance of:

* Traditional `for` loops
* The use of `in` operator with an array (not recommended)
* The built-in `Array.prototype.forEach()` method

**Pros and Cons**

* **Traditional `for` loops**:
	+ Pros: Simple, predictable, and efficient.
	+ Cons: Can be verbose for large arrays or complex iterations.
* **Using `in` operator with an array**: (Not recommended)
	+ Pros: None.
	+ Cons: Insecure (because it can access own properties of the array), not supported in all browsers, and not suitable for modern JavaScript use cases.
* **Built-in `Array.prototype.forEach()` method**:
	+ Pros: Concise, efficient, and widely supported across browsers.
	+ Cons: May have some performance overhead compared to traditional loops.

**Library/Functionality**

The test case uses the `console.log()` function, which is a built-in JavaScript functionality for printing output to the console. There are no external libraries involved in this benchmark.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax mentioned in these test cases. They use standard JavaScript features available since the early days of JavaScript.

**Alternatives**

Other alternatives for iterating over arrays could include:

* `Array.prototype.forEach.call()`: A version of the `forEach()` method that takes an array as its first argument.
* `for...of` loops: Introduced in ECMAScript 2015 (ES6), these loops provide a more concise and readable way to iterate over arrays, objects, and other iterable values.

Keep in mind that the performance differences between these alternatives are usually negligible unless you're working with extremely large datasets or highly optimized code.

Latest run results:

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

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

Browser/OS: Chrome 79 on Linux

View result in a separate tab

Test name	Executions per second
for	62734.9 Ops/sec
for each	112199.7 Ops/sec
forEach	112300.1 Ops/sec

Related benchmarks:

for/for each/forEach1 (version: 0)

Comparing performance of: for vs for each vs forEach

Created: 4 years ago by: Guest

Jump to the latest result

for

for each

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