Benchmark: For Each comparison

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.2/lodash.min.js'></script>

Script Preparation code:

var count = 100000
var myArray = [];

for (var i = 0; i < count; i++) { myArray.push(Math.random() * 5) }

Array.prototype.forEach2=function(a){
    var l=this.length;
    for(var i=0;i<l;i++)a(this[i],i)
}

Tests:

lodash forEach
_.forEach(myArray, (value, index) => { myArray[index] = value + 1; });
Array.prototype.forEach()
myArray.forEach((value, index) => { myArray[index] = value + 1; });
Traditional for loop
for (var index = 0; index < myArray.length; index++) { myArray[index] = myArray[index] + 1; }
Custom Array.prototype.forEach()
myArray.forEach2((value, index) => { myArray[index] = value + 1; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash forEach
Array.prototype.forEach()
Traditional for loop
Custom Array.prototype.forEach()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
lodash forEach	93.9 Ops/sec
Array.prototype.forEach()	111.0 Ops/sec
Traditional for loop	51.3 Ops/sec
Custom Array.prototype.forEach()	128.3 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of three different approaches to increment each element in an array by 1:

1. **Custom Array.prototype.forEach()**: A custom implementation of `forEach()` that takes a callback function as its second argument.
2. **Lodash forEach**: The `forEach` function from the Lodash library, which is a popular utility library for JavaScript.
3. **Traditional for loop**: A traditional for loop that iterates over the array using an index variable.

**What is tested?**

The benchmark tests the execution speed of each approach in three different scenarios:

* Each element in an array of 100,000 random numbers is incremented by 1.
* The callback function passed to `forEach()` takes two arguments: the current value and its index in the array.
* The `forEach` function from Lodash is used instead of the custom implementation.

**Options compared**

The benchmark compares the performance of three different approaches:

1. **Custom Array.prototype.forEach()**: A custom implementation of `forEach()` that takes a callback function as its second argument.
2. **Lodash forEach**: The `forEach` function from the Lodash library.
3. **Traditional for loop**: A traditional for loop that iterates over the array using an index variable.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Custom Array.prototype.forEach()**:
	* Pros: Customizable, flexible, and easy to understand.
	* Cons: May not be as efficient as other implementations due to the overhead of creating a custom function.
2. **Lodash forEach**:
	* Pros: Optimized for performance, widely used and tested, and part of a larger utility library.
	* Cons: Requires an external dependency (Lodash), may have licensing restrictions.
3. **Traditional for loop**:
	* Pros: Simple, easy to understand, and performs well when optimized.
	* Cons: Less flexible than other implementations, can be slower due to the overhead of using an index variable.

**Library usage**

The Lodash library is used in this benchmark as a reference implementation for the `forEach` function. The custom implementation of `forEach()` is also provided as an alternative approach.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes mentioned in this benchmark, but it's worth noting that MeasureThat.net supports testing various JavaScript features and libraries, such as async/await, promise-based I/O, and more.

**Other alternatives**

If you'd like to compare other approaches, here are some suggestions:

1. **ES6 for...of loop**: A new iteration of the traditional for loop that uses an iterator object to iterate over arrays.
2. **Array.prototype.map()**: A method that creates a new array with the results of applying a provided function to each element in the original array.
3. **Destructuring assignment**: A feature that allows you to extract multiple values from an array or object into separate variables.

Feel free to explore these alternatives on MeasureThat.net and compare their performance!

Related benchmarks:

For Each comparison (version: 0)

Comparing performance of: lodash forEach vs Array.prototype.forEach() vs Traditional for loop vs Custom Array.prototype.forEach()

Created: 6 years ago by: Registered User

Jump to the latest result

lodash forEach

Array.prototype.forEach()

Traditional for loop

Custom Array.prototype.forEach()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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