Benchmark: Filter-Map: Lodash FP vs Native code

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.fp.min.js"></script>

Script Preparation code:

var data = Array(1000000).fill({ filtering: true, mapping: 42 });

Tests:

Native filter-map
data .filter(({ filtering }) => filtering) .map(({ mapping }) => mapping)
Lodash FP filter-map
_.pipe( _.filter(({ filtering }) => filtering), _.map(({ mapping }) => mapping) )(data)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native filter-map
Lodash FP filter-map

Fastest: N/A

Slowest: N/A

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

Browser/OS: Chrome 76 on Windows

View result in a separate tab

Test name	Executions per second
Native filter-map	5.6 Ops/sec
Lodash FP filter-map	18.3 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares two approaches to filter and map an array of objects:

1. Native code (using JavaScript's built-in `filter` and `map` methods)
2. Lodash Functional Programming (FP) API, specifically the `_.pipe()` method

**Options Compared**

Two options are being compared:

* **Native Code**: Uses JavaScript's native `filter` and `map` methods.
* **Lodash FP**: Uses Lodash's FP API, specifically the `_`.pipe()` method.

**Pros and Cons of Each Approach**

### Native Code

Pros:

* Faster execution times: Native code executes directly on the JavaScript engine, which is optimized for speed.
* Less overhead: No additional library or framework dependencies.

Cons:

* Less readable and maintainable: The code can be more complex and harder to understand due to its native implementation.
* Less flexible: Limited by the capabilities of the JavaScript engine.

### Lodash FP

Pros:

* More readable and maintainable: The code is often easier to understand and debug, thanks to the concise and expressive nature of FP APIs.
* More flexible: Provides a wider range of utility functions for various tasks.

Cons:

* Slower execution times: Lodash's FP API incurs additional overhead due to the use of function composition.
* Additional library dependency: Requires including the Lodash library in the project, which may add bloat.

**Library and Purpose**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like data manipulation, string processing, and more. The FP API is part of this library and offers a concise way to compose functions together using `_.pipe()`.

**Special JS Feature/Syntax**

No special JavaScript features or syntax are being used in these benchmarks. They only rely on standard JavaScript language features.

**Alternatives**

Other alternatives for filtering and mapping arrays include:

* Using other functional programming libraries, such as Ramda or Underscore.js.
* Utilizing a database library like MongoDB to perform data manipulation.
* Leveraging a dedicated streaming library, such as Fastify's `stream` module.

Keep in mind that the choice of implementation depends on the specific use case and requirements. In some cases, native code might be preferred for its speed, while Lodash FP or other libraries might be chosen for their expressiveness and flexibility.

Related benchmarks:

Filter-Map: Lodash FP vs Native code (version: 0)

Comparing performance of: Native filter-map vs Lodash FP filter-map

Created: 5 years ago by: Guest

Jump to the latest result

Native filter-map

Lodash FP filter-map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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