Benchmark: lodash.each vs Object.forEach

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var value = [{a: 30310}, {b: 100303}, {c: 3040494}]

Tests:

lodash.each
_.each(value, function(v,i) {})
native
value.forEach(function(v,i) {})
for loop
for (let i = 0; i < value.length; i++) { const v = value[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 29 days ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares three approaches to iterate over an array:

1. `lodash.each`
2. Native `forEach` (a built-in JavaScript method)
3. For loop (a manual iteration using a traditional `for` statement)

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides various functions for tasks like array manipulation, functional programming, and more. In this benchmark, `lodash.each` is used to iterate over the input array.

The `_.each` function takes two arguments:

* An array (`value`) to iterate over
* A callback function (in this case, an anonymous function that takes two arguments: `v` and `i`, representing each element in the array and its index, respectively)

**Comparison**

Here's a brief overview of each approach:

1. **Lodash `.each`**: This method uses a library function to perform iteration over the input array. It provides some overhead due to the function call and setup, but it also allows for more flexibility and expressiveness in the callback function.
2. **Native `forEach`**: Built-in JavaScript methods like `forEach` are typically faster than library functions because they don't incur additional overhead. However, this method requires a specific browser support (Chrome 65 in this case) and doesn't provide as much control over iteration flow.
3. **For loop**: This approach is the most low-level and manual way to iterate over an array. It provides complete control over the iteration process but requires more code and can be less readable.

**Pros and Cons**

Here are some key points to consider for each approach:

* Lodash `.each`:
	+ Pros: More flexible, allows for more complex logic in the callback function
	+ Cons: Additional library overhead, slower due to setup
* Native `forEach`:
	+ Pros: Faster, minimal overhead
	+ Cons: Limited control over iteration flow, requires specific browser support
* For loop:
	+ Pros: Complete control over iteration process, no additional overhead
	+ Cons: More code required, less readable

**Test Results**

According to the benchmark results, the order of performance is:

1. Native `forEach` (Chrome 65): highest executions per second (11775501.0)
2. Lodash `.each`: moderate execution speed (2851002.25)
3. For loop: lowest execution speed (1739479.0)

**Special Considerations**

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

**Alternatives**

If you're looking for alternative benchmarks or want to explore more advanced topics, consider the following options:

* Other Lodash functions: MeasureThat.net has a wide range of benchmarks that compare different Lodash functions, such as `.map`, `.filter`, and `.reduce`.
* Vanilla JavaScript vs. Modern JavaScript: Explore the performance differences between vanilla JavaScript (without modern features like async/await or destructuring) and modern JavaScript (with these features).
* WebAssembly benchmarks: Measure the performance of compiled WebAssembly code on different browsers and platforms.

I hope this explanation helps you understand the context and nuances of this benchmark!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36

Browser/OS: Chrome 65 on Mac OS X 10.13.4

View result in a separate tab

Test name	Executions per second
lodash.each	2851002.2 Ops/sec
native	11775501.0 Ops/sec
for loop	1739479.0 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 29 days ago):