Benchmark: Map - Native vs Lodash vs Ramda vs Sanctuary 10,000

HTML Preparation code:

<script src="https://unpkg.com/lodash@4.17.11/lodash.min.js"></script>
<script src="https://unpkg.com/ramda@0.26.1/dist/ramda.min.js"></script>
<script src="https://unpkg.com/sanctuary-show@1.0.0/index.js"></script>
<script src="https://unpkg.com/sanctuary-type-identifiers@2.0.1/index.js"></script>
<script src="https://unpkg.com/sanctuary-type-classes@9.0.0/index.js"></script>
<script src="https://unpkg.com/sanctuary-either@1.0.0/index.js"></script>
<script src="https://unpkg.com/sanctuary-maybe@1.0.0/index.js"></script>
<script src="https://unpkg.com/sanctuary-pair@1.0.0/index.js"></script>
<script src="https://unpkg.com/sanctuary-def@0.18.1/index.js"></script>
<script src="https://unpkg.com/sanctuary@0.15.0/index.js"></script>

Script Preparation code:

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

Tests:

Native
data.map(double);
Lodash
_.map(data, double);
Ramda
R.map(double, data);
Sanctuary
sanctuary.map(double)(data);
Native for loop js
const mapped = [...data] for (let i = data.length; i--;){ mapped[i] = double(data[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Lodash
Ramda
Sanctuary
Native for loop js

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and discussed.

**Benchmark Overview**

MeasureThat.net is testing the performance of four different approaches to map over an array:

1. Native (built-in JavaScript array method)
2. Lodash (a popular JavaScript utility library)
3. Ramda (another well-known functional programming library)
4. Sanctuary (a functional programming library with a focus on type safety)

**Benchmark Definition JSON**

The benchmark definition JSON contains the following information:

* `Name`: The name of the benchmark, which is "Map - Native vs Lodash vs Ramda vs Sanctuary 10,000".
* `Description`: An empty description.
* `Script Preparation Code`: A JavaScript function that generates an array of 10,000 elements with incremental indices. This array will be used for mapping operations.
* `Html Preparation Code`: A list of scripts that include various libraries (Lodash, Ramda, Sanctuary) and their dependencies.

**Individual Test Cases**

There are four test cases:

1. **Native**: Tests the built-in JavaScript array method `map`.
2. **Lodash**: Tests the `_.map` function from Lodash.
3. **Ramda**: Tests the `R.map` function from Ramda.
4. **Sanctuary**: Tests the `sanctuary.map` function from Sanctuary.

**Options Compared**

The four test cases compare different approaches to map over an array:

* Native: Built-in JavaScript array method
* Lodash: A popular JavaScript utility library with a `map` function
* Ramda: Another well-known functional programming library with a `map` function
* Sanctuary: A functional programming library with a focus on type safety, also providing a `map` function

**Pros and Cons of Each Approach**

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

* Native:
	+ Pros: Fast, efficient, and widely supported.
	+ Cons: May not be as readable or maintainable as other approaches.
* Lodash:
	+ Pros: Well-documented, widely used, and provides a range of utility functions.
	+ Cons: Adds external dependency (Lodash library), may be slower than native implementation.
* Ramda:
	+ Pros: Functional programming paradigm, provides a predictable and composable API.
	+ Cons: May require additional learning curve due to functional programming concepts.
* Sanctuary:
	+ Pros: Focus on type safety, provides a strong foundation for functional programming.
	+ Cons: May be slower than native implementation, requires additional learning curve.

**Other Considerations**

When choosing an approach, consider the following factors:

* Performance: Native implementation is likely to be the fastest, but may not be as maintainable. Lodash and Ramda implementations may be slower due to added dependencies.
* Readability and Maintainability: Sanctuary's type-safe API may make code more readable and maintainable, while Lodash provides a well-documented and widely used API.

**Alternatives**

If you're looking for alternatives to the four approaches tested in this benchmark:

* For a purely functional programming approach without external dependencies, consider using a library like Immutable.js.
* For a high-performance implementation without sacrificing readability, consider using a specialized array library like FastArray or Array.prototype.mapWithIndex.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.2

View result in a separate tab

Test name	Executions per second
Native	4999081.0 Ops/sec
Lodash	4476095.0 Ops/sec
Ramda	1951030.9 Ops/sec
Sanctuary	868.9 Ops/sec
Native for loop js	2303379.2 Ops/sec

Related benchmarks:

Map - Native vs Lodash vs Ramda vs Sanctuary 10,000 (version: 0)

Comparing performance of: Native vs Lodash vs Ramda vs Sanctuary vs Native for loop js

Created: 5 years ago by: Guest

Jump to the latest result

Native

Lodash

Ramda

Sanctuary

Native for loop js

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