Benchmark: Map (Native vs Ramda vs Lodash vs Immutable) - sample size 100

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>
<script type='text/javascript' src='https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js'></script>

Script Preparation code:

function double(n) {
	return n*2;
}
var data = [...Array(10000)].map((n, idx) => idx);

Tests:

Ramda.map
R.map(double, data);
Array.prototype.map
data.map(double);
lodash.map
_.map(data, double);
Immutable.map
Immutable.fromJS(data).map(double)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda.map
Array.prototype.map
lodash.map
Immutable.map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is tested on the provided JSON.

The benchmark measures the speed of different ways to perform mapping operations on arrays in JavaScript:

1. **Ramda.map**: Ramda is a functional programming library for JavaScript. The `map` function in Ramda takes two arguments: the function to be applied to each element, and the array to be mapped over.
2. **Array.prototype.map**: This is the native way to perform mapping on arrays in JavaScript. It iterates over each element in the array and applies a provided function to it, returning a new array with the results.
3. **Lodash.map**: Lodash is another popular utility library for JavaScript that provides various helper functions, including `map`. The `map` function in Lodash works similarly to Ramda's `map`, but has some additional features like memoization.
4. **Immutable.map**: Immutable.js is a library for working with immutable data structures in JavaScript. The `map` function in Immutable.js applies a provided function to each element of an immutable array, returning a new immutable array.

The benchmark prepares the test data by creating an array of 10,000 elements and doubling each value using the `double` function. This allows us to focus solely on the mapping performance of each library or method.

Let's look at some pros and cons of each approach:

* **Ramda.map**:
	+ Pros: Efficient, concise code; easy to read and understand.
	+ Cons: Requires external dependency (Ramda); not as widely supported as native JavaScript methods.
* **Array.prototype.map**:
	+ Pros: Native JavaScript method; well-supported across all browsers and environments.
	+ Cons: Can be slower than optimized libraries like Ramda or Immutable.js.
* **Lodash.map**:
	+ Pros: Provides additional features like memoization, which can improve performance in some cases.
	+ Cons: Adds an external dependency (Lodash); may not be as efficient as native JavaScript methods.
* **Immutable.map**:
	+ Pros: Immutable data structures provide a predictable and thread-safe way to work with data; easy to reason about code behavior.
	+ Cons: Can be slower than optimized libraries like Ramda or Lodash due to the overhead of creating immutable data structures.

In terms of performance, the results show that:

* **Lodash.map** is the fastest, followed closely by **Array.prototype.map**, and then **Ramda.map**.
* **Immutable.map** is the slowest due to the overhead of creating immutable data structures.

The benchmark highlights the importance of considering the trade-offs between conciseness, readability, and performance when choosing a mapping library or method for your specific use case.

Latest run results:

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

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

Browser/OS: Chrome 71 on Windows

View result in a separate tab

Test name	Executions per second
Ramda.map	8547.0 Ops/sec
Array.prototype.map	6004.9 Ops/sec
lodash.map	28588.0 Ops/sec
Immutable.map	398.6 Ops/sec

Related benchmarks:

Map (Native vs Ramda vs Lodash vs Immutable) - sample size 100 (version: 0)

measures the speed of ramda's map vs Array's native map vs lodash map vs Immutable map

Comparing performance of: Ramda.map vs Array.prototype.map vs lodash.map vs Immutable.map

Created: 6 years ago by: Guest

Jump to the latest result

Ramda.map

Array.prototype.map

lodash.map

Immutable.map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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