Benchmark: lodash .foreach vs native foreach vs native for loop

HTML Preparation code:


<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js'></script>

Script Preparation code:

var value = [{a: 30310}, {b: 100303}, {c: 3040494}, {d: 6542321}, {e: 13123531}]

Tests:

lodash
_.forEach(value, function(v,i) {console.log(v)})
native
value.forEach(function(v,i) {console.log(v)})
for loop
for (let i = 0; i < value.length; i++) { console.log(value[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
native
for loop

Fastest: N/A

Slowest: N/A

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/136.0.0.0 Safari/537.36 Edg/136.0.0.0

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
lodash	64785.8 Ops/sec
native	66846.2 Ops/sec
for loop	79511.7 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark is designed to compare the performance of three different approaches in JavaScript: Lodash's `forEach` function, native `foreach` loop, and native `for` loop.

**Options Compared**

The benchmark tests the execution speed of each approach on a predefined array of objects (`value`) with five elements. The three options being compared are:

1. **Lodash's `forEach` function**: This is a utility function provided by the Lodash library that iterates over an array and executes a callback function for each element.
2. **Native `foreach` loop**: This is a built-in JavaScript method that allows iterating over an array using a traditional `for` loop syntax.
3. **Native `for` loop**: This is another built-in JavaScript construct that allows looping through an array using a traditional `for` loop syntax.

**Pros and Cons of Each Approach**

1. **Lodash's `forEach` function**:
	* Pros: Concise code, easy to read and write, and provides a clear benefit over native loops when dealing with complex logic.
	* Cons: External dependency (Lodash library), slower performance compared to native loops due to the overhead of the library.
2. **Native `foreach` loop**:
	* Pros: Fastest execution speed, no external dependencies, and allows for more control over iteration logic.
	* Cons: More verbose code, requires a deeper understanding of JavaScript syntax and iteration mechanics.
3. **Native `for` loop**:
	* Pros: Lightweight and easy to understand, allowing for quick prototyping and development.
	* Cons: Slowest execution speed among the three options, may not be suitable for large-scale applications.

**Library Used**

The Lodash library is used in the benchmark, specifically version 4.17.10. Lodash provides a wide range of utility functions that can simplify code writing and improve performance.

**Special JS Feature or Syntax (Not Applicable)**

There are no special JavaScript features or syntax being tested in this benchmark.

**Alternatives**

Other alternatives for iterating over arrays in JavaScript include:

1. `Array.prototype.forEach()`: This is a built-in method of the Array prototype that allows iterating over an array using a callback function.
2. `Array.prototype.map()` and `Array.prototype.filter()`: These methods can be used to transform or filter arrays, but may not be suitable for all use cases.

In summary, this benchmark provides a useful comparison between three different approaches to iterating over arrays in JavaScript, highlighting the trade-offs between conciseness, performance, and control.

Related benchmarks:

lodash .foreach vs native foreach vs native for loop (version: 0)

Comparing performance of: lodash vs native vs for loop

Created: one year ago by: Guest

Jump to the latest result

lodash

native

for loop

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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