Benchmark: lodash.each vs Object.forEach

HTML Preparation code:

<script src="//ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

Script Preparation code:


// Populate the base array
var arr = [];
for (var i = 0; i < 1000; i++) {
  arr[i] = i;
}

function fn(a) {
  return a * 2 * 5;
}

Tests:

lodash.each
_.forEach(arr,fn)
native
arr.forEach(fn)
for loop
for(i=0;i<arr.length;i++) fn(arr[i]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
native
for loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark compares three approaches to iterate over an array:

1. **Lodash `_.forEach`**: Uses the `forEach` method provided by Lodash, a popular utility library for JavaScript.
2. **Native `arr.forEach`**: Uses the native `forEach` method provided by JavaScript, which is built-in and doesn't require any additional libraries.
3. **Manual `for` loop**: Uses a traditional `for` loop to iterate over the array.

**Pros and Cons of each approach**

1. **Lodash `_.forEach`**:
	* Pros: Easy to use, concise, and efficient (since Lodash is optimized for performance).
	* Cons: Requires an additional library dependency (Lodash), which might add overhead.
2. **Native `arr.forEach`**:
	* Pros: Built-in and doesn't require any additional libraries, making it a lightweight option.
	* Cons: May be less efficient than the Lodash implementation, especially for large arrays.
3. **Manual `for` loop**:
	* Pros: Control over iteration and no dependencies on external libraries.
	* Cons: Can be verbose, error-prone, and slower due to the overhead of the loop.

**Library and its purpose**

Lodash is a utility library that provides a set of functional programming helpers, including `forEach`. It's a popular choice for JavaScript development because it simplifies common tasks and provides performance optimizations.

**Special JS feature or syntax**

None mentioned in this benchmark. The code uses standard JavaScript features and syntax.

**Benchmark Results**

The results show the execution rate (executions per second) of each approach on a Chrome 88 browser:

1. **Native `arr.forEach`**: 84409.4375 executions/second
2. **Lodash `_.forEach`**: 74448.984375 executions/second
3. **Manual `for` loop**: 3626.494384765625 executions/second

As expected, the native implementation is the fastest, followed closely by Lodash's optimized implementation. The manual `for` loop is significantly slower.

**Other alternatives**

If you want to explore alternative approaches, here are a few options:

1. **Array.prototype.reduce()**: Instead of using `forEach`, you could use `reduce()` to iterate over the array.
2. **Closures**: You could define a closure function that iterates over the array using traditional JavaScript syntax.
3. **Modern JavaScript features**: If available, you could use modern JavaScript features like `for...of` loops or `Map.forEach()` for iteration.

Keep in mind that these alternatives might have different performance characteristics and may not be suitable for all scenarios.

Latest run results:

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

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

Browser/OS: Chrome 88 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	74449.0 Ops/sec
native	84409.4 Ops/sec
for loop	3626.5 Ops/sec

Related benchmarks:

lodash.each vs Object.forEach (version: 0)

Comparing performance of: lodash.each vs native vs for loop

Created: 6 years ago by: Guest

Jump to the latest result

lodash.each

native

for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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