Benchmark: forEach – native or for?

Script Preparation code:

function fastforEach(subject, iterator) {
  const length = subject.length;
  for (let i = 0; i < length; i++) {
    iterator(subject[i], i, subject);
  }
};

var testingArray = [1,2,3];

Tests:

native
testingArray.forEach((v) => v+1);
fastForEach
fastforEach(testingArray, (v) => v+1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
fastForEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its results.

**Benchmark Overview**

The benchmark compares two approaches for iterating over an array: the native `forEach` method and a custom implementation called `fastforEach`. The goal is to measure which approach is faster in modern JavaScript engines.

**Options Compared**

There are two options compared:

1. **Native `forEach`**: This is the standard JavaScript method for iterating over arrays, which invokes the callback function for each element in the array.
2. **Custom `fastforEach`**: This implementation uses a traditional `for` loop to iterate over the array elements, allowing for more control over performance.

**Pros and Cons**

* **Native `forEach`:**
	+ Pros: Simple and intuitive, easy to read and maintain.
	+ Cons: May be slower due to additional overhead of invoking the callback function for each element.
* **Custom `fastforEach`:**
	+ Pros: Can potentially be faster since it bypasses the callback function invocation overhead.
	+ Cons: More complex implementation that requires manual memory management and iteration logic.

**Library Usage**

There is no library usage in this benchmark. The custom implementation uses a traditional `for` loop, which is not reliant on any external libraries.

**Special JavaScript Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. Both the native `forEach` and custom `fastforEach` implementations use standard JavaScript constructs.

**Other Considerations**

When writing performance-critical code, it's essential to consider the following factors:

* Memory allocation and deallocation: Custom implementations can lead to memory leaks if not properly managed.
* Cache locality: Iterators that access elements in a contiguous block of memory can improve cache performance.
* Branch prediction: Modern CPUs use branch prediction to optimize execution. In this case, the custom `fastforEach` implementation may benefit from better branch prediction due to its more predictable iteration order.

**Alternatives**

Other alternatives for iterating over arrays include:

* `for...in`: This method iterates over an object's properties using a traditional `for` loop.
* `Array.prototype.forEach.call()`: This method calls the `forEach` method on an array, passing in an additional context argument.
* Library-based solutions like Lodash's `forEach()` or Ramda's `map()`, which provide optimized iteration methods for arrays.

Keep in mind that these alternatives may have their own trade-offs and performance characteristics.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
native	6182298.5 Ops/sec
fastForEach	3322411.5 Ops/sec

Related benchmarks:

forEach – native or for? (version: 4)

Comparing performance of: native vs fastForEach

Created: 7 years ago by: Registered User

Jump to the latest result

native

fastForEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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