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.pipe( R.add(5), R.subtract(3), R.multiply(10), R.divide(2) )(0)
Array.prototype.map
const t = ((0 + 5 - 3) * 10) / 2
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 24 days ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Overview**

The benchmark is comparing the performance of different JavaScript functions for mapping over an array:

1. `Array.prototype.map` (native JavaScript)
2. `lodash.map` (a popular utility library)
3. `Ramda.map` (a functional programming library)
4. `Immutable.map` (from the Immutable.js library, which provides immutable data structures)

**Benchmark Definition**

The benchmark definition is a JSON object that describes the test case. In this case, each test case has a single line of code that performs the same operation on an array:

* `R.pipe(R.add(5), R.subtract(3), R.multiply(10), R.divide(2))(0)` (Ramda)
* `const t = ((0 + 5 - 3) * 10) / 2` (Array.prototype.map)
* `_.map(data, double);` (lodash.map)
* `Immutable.fromJS(data).map(double)` (Immutable.map)

The `double` function is defined elsewhere in the script.

**Options Compared**

Each test case compares a different JavaScript implementation for mapping over an array:

1. Native JavaScript (`Array.prototype.map`)
2. Lodash (`_.map`)
3. Ramda (`R.map`)
4. Immutable.js (`Immutable.map`)

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

* **Native JavaScript (Array.prototype.map)**:
	+ Pros: Well-supported by most browsers, fast execution.
	+ Cons: Can be slower for large datasets due to DOM manipulation overhead.
* **Lodash (`_.map`)**:
	+ Pros: Easy to use, well-documented, widely supported.
	+ Cons: Adds unnecessary weight to the application, can be slow for very large datasets.
* **Ramda (`R.map`)**:
	+ Pros: Functional programming paradigm provides a more expressive and composable API.
	+ Cons: Can be slower than native JavaScript due to additional function calls and data structures.
* **Immutable.js (`Immutable.map`)**:
	+ Pros: Provides immutable data structures, which can improve performance in some cases (e.g., when working with large datasets).
	+ Cons: Adds unnecessary weight to the application, requires more memory for intermediate results.

**Library Descriptions**

1. **Ramda**: A functional programming library that provides a collection of higher-order functions for working with arrays and other data structures.
2. **Immutable.js**: A library that provides immutable data structures and utility functions for working with them.

**Special JS Features/Syntax**

None mentioned in the provided code snippets. However, it's worth noting that Ramda uses a functional programming paradigm, which may require additional knowledge of JavaScript syntax and concepts (e.g., arrow functions, higher-order functions).

**Alternatives**

If you're interested in exploring alternative libraries or approaches for mapping over arrays, here are some options:

1. **Preact**: A lightweight, modular alternative to React that provides a similar API for functional components.
2. **Svelte**: A modern web framework that compiles your code into efficient JavaScript and HTML, providing a fast and scalable way to build user interfaces.
3. **V8 engine**: The JavaScript engine used by Google Chrome, which can be used as a benchmarking tool or integrated into applications for performance optimization.

Keep in mind that each library or approach has its strengths and weaknesses, and the choice of implementation will depend on your specific use case, performance requirements, and personal preferences.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 118 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Ramda.map	1947655.2 Ops/sec
Array.prototype.map	1009441344.0 Ops/sec
lodash.map	5575260.0 Ops/sec
Immutable.map	939556.2 Ops/sec

Related benchmarks:

Map (Native vs Ramda vs Lodash vs Immutable (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: 5 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 24 days ago):