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

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 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!

Latest run results:

Run details: (Test run date: 28 days 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

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 one month ago):