Benchmark: Map (Native vs Ramda vs Lodash vs Immutable)

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 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

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

Latest run results:

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

User agent: Mozilla/5.0 (Android 15; Mobile; rv:144.0) Gecko/144.0 Firefox/144.0

Browser/OS: Firefox Mobile 144 on Android

View result in a separate tab

Test name	Executions per second
Ramda.map	2636301.8 Ops/sec
Array.prototype.map	4254229.0 Ops/sec
lodash.map	3313478.0 Ops/sec
Immutable.map	263207.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test cases for Map operations.

**What is tested?**

The test measures the performance of four different map functions:

1. Native Array.prototype.map
2. Ramda's R.map
3. Lodash's _.map
4. Immutable.js's Immutable.map

Each function is applied to a large array of numbers (`data`) and a transformation function (`double(n) = n * 2`).

**Options compared**

The test compares the performance of these four map functions, which differ in their implementation details:

1. **Native Array.prototype.map**: This is the built-in JavaScript method for mapping an array's elements. It's a simple and lightweight implementation that uses a single loop to iterate over the array.
2. **Ramda's R.map**: Ramda is a functional programming library that provides a more concise and expressive way of mapping arrays. Its `R.map` function uses a similar approach as the native method, but with additional features like caching and memoization.
3. **Lodash's _.map**: Lodash is another popular utility library that provides a wide range of functions for tasks like mapping. Its `_.map` function is similar to Ramda's, but with some differences in implementation details.
4. **Immutable.js's Immutable.map**: Immutable.js is a library designed for working with immutable data structures. Its `Immutable.map` function creates a new, immutable array by applying the transformation function to each element.

**Pros and Cons of each approach**

1. **Native Array.prototype.map**:
	* Pros: Lightweight, simple implementation, widely supported.
	* Cons: May not be as efficient or expressive as other implementations.
2. **Ramda's R.map**:
	* Pros: More concise and expressive than native implementation, caching/memoization for performance improvements.
	* Cons: Additional dependencies, may not be suitable for all use cases.
3. **Lodash's _.map**:
	* Pros: Similar to Ramda's, with some additional features like debouncing.
	* Cons: Another dependency, similar limitations as Ramda's.
4. **Immutable.js's Immutable.map**:
	* Pros: Provides immutable data structures, which can be beneficial for certain use cases.
	* Cons: Heavier-weight implementation, may not be necessary for most use cases.

**Library descriptions**

1. **Ramda**: A functional programming library providing a wide range of higher-order functions for tasks like mapping, filtering, and reducing.
2. **Lodash**: A utility library providing a vast array of helper functions for common tasks, including mapping, filtering, and modifying arrays.
3. **Immutable.js**: A library designed for working with immutable data structures, providing efficient and thread-safe operations.

**Special JS features or syntax**

None mentioned in the provided benchmarking test cases.

**Alternatives**

Other alternatives for map-like functionality include:

1. **Underscore.js**: Another utility library that provides a similar mapping function to Lodash.
2. **Fastify's `map` method**: A lightweight, built-in method for mapping arrays in Fastify, a web framework.
3. **V8's built-in `Array.prototype.map` optimization**: Google's V8 JavaScript engine uses various optimizations, including caching and loop unrolling, to improve performance of the native Array.prototype.map method.

In conclusion, the test compares the performance of four different map functions: native Array.prototype.map, Ramda's R.map, Lodash's _.map, and Immutable.js's Immutable.map. Each function has its pros and cons, and understanding their differences can help developers choose the most suitable implementation for specific use cases.

Related benchmarks:

Map (Native vs Ramda vs Lodash vs Immutable) (version: 1)

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: 8 years ago by: Registered User

Jump to the latest result

Ramda.map

Array.prototype.map

lodash.map

Immutable.map

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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