Benchmark: test124578 - MeasureThat.net

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, l = myArray.length; index < l; 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 break down the provided JSON data and explain what's being tested.

**Benchmark Definition**

The `Script Preparation Code` section of the benchmark definition contains a script that initializes an array `myArray` with 100,000 random values between 0 and 5. It also defines a custom `forEach2` function on the `Array.prototype`. This function takes two arguments: the value to be processed and its index in the array.

**Options Compared**

The benchmark tests four different approaches:

1. **Custom Array.prototype.forEach**: The built-in `forEach` function is overridden with a custom implementation defined in the script preparation code.
2. **Array.prototype.forEach()**: The standard `forEach` function on the `Array.prototype`.
3. **Traditional for loop**: A traditional for loop is used to iterate over the array and increment each value.
4. **Lodash forEach**: Lodash's built-in `forEach` function is used.

**Pros and Cons**

1. **Custom Array.prototype.forEach**:
	* Pros: Can be optimized for specific use cases, provides fine-grained control over iteration.
	* Cons: May not work as expected in all scenarios due to its custom implementation.
2. **Array.prototype.forEach()**:
	* Pros: Standard implementation, widely supported and maintained by the JavaScript community.
	* Cons: May not provide optimal performance for specific use cases.
3. **Traditional for loop**:
	* Pros: Simple and well-understood, easy to implement.
	* Cons: Can be slower than other approaches due to its iterative nature.
4. **Lodash forEach**:
	* Pros: Part of a popular utility library, provides optimized and tested implementation.
	* Cons: Requires an additional dependency (Lodash), may not provide the best performance for all scenarios.

**Other Considerations**

The benchmark also includes device platform, operating system, and browser information to provide context for the results. Additionally, the `ExecutionsPerSecond` metric gives an idea of how many iterations each approach can perform in a second.

**Library and Feature Explanation (Lodash)**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like array manipulation, string processing, and more. The `forEach` function in Lodash is an optimized implementation that leverages browser optimizations like caching and memoization to improve performance.

The use of Lodash's `forEach` function in the benchmark adds an additional layer of complexity, as it requires the test runner to include the library and handle its dependencies. However, this can also provide valuable insights into the performance differences between built-in functions and optimized libraries like Lodash.

Latest run results:

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

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

Browser/OS: Chrome 69 on Windows

View result in a separate tab

Test name	Executions per second
lodash forEach	92.2 Ops/sec
Array.prototype.forEach()	86.3 Ops/sec
Traditional for loop	55.5 Ops/sec
Custom Array.prototype.forEach()	98.8 Ops/sec

Related benchmarks:

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