Benchmark: lodash.each vs Object.forEach vs lodash map

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) {})
lodash.map
_.map(value, function(v,i) {})
lodash.forEach
_.forEach(value, function(v,i) {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
native
lodash.map
lodash.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.

The provided JSON represents a benchmark test suite for JavaScript microbenchmarks on the MeasureThat.net website.

**What is tested?**

The benchmark tests four different approaches to iterate over an array in JavaScript:

1. `lodash.each`
2. `native` (the built-in `forEach` method)
3. `lodash.map`

These approaches are compared in terms of execution speed, which is measured by the number of executions per second.

**Options comparison**

The benchmark compares three options:

* `lodash.each`: a function from the Lodash library that applies a provided function to each element of an array.
* `native`: the built-in `forEach` method in JavaScript, which applies a provided function to each element of an array.
* `lodash.map`: another function from the Lodash library that returns a new array with the results of applying a provided function to each element of the original array.

**Pros and cons**

Here are some pros and cons of each approach:

* `lodash.each`:
	+ Pros: often provides better performance due to its optimized implementation.
	+ Cons: requires importing an additional library, which may introduce overhead.
* `native`: using the built-in `forEach` method is generally convenient and efficient, but may not always be as performant as custom implementations like `lodash.each`.
* `lodash.map`:
	+ Pros: can provide good performance for certain use cases (e.g., when creating a new array).
	+ Cons: creates an additional intermediate array, which may not be desirable in all situations.

**Library and syntax**

The benchmark uses the Lodash library, which is a popular JavaScript utility library that provides a wide range of functions for tasks such as string manipulation, array manipulation, and more. The `lodash.each`, `lodash.forEach`, and `lodash.map` functions are part of this library.

No special JavaScript features or syntax are used in this benchmark.

**Other alternatives**

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

* Using `Array.prototype.reduce()` instead of `forEach`.
* Implementing a custom loop using a `for` loop or a `while` loop.
* Using a library like Underscore.js (similar to Lodash) or Ramda.

Keep in mind that these alternatives may not always provide the same performance as optimized libraries like Lodash, and may require more manual optimization and tuning.

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/87.0.4280.141 Safari/537.36

Browser/OS: Chrome 87 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	2791309.2 Ops/sec
native	10765332.0 Ops/sec
lodash.map	3333224.5 Ops/sec
lodash.forEach	2858327.2 Ops/sec

Related benchmarks:

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

Comparing performance of: lodash.each vs native vs lodash.map vs lodash.forEach

Created: 6 years ago by: Guest

Jump to the latest result

lodash.each

native

lodash.map

lodash.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):