Benchmark: native lodash filter map 2dsfg

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

Script Preparation code:

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

Tests:

native lodash filter map
data.filter(({ filtering }) => filtering).map(({ mapping }) => mapping)
Lazy Lodash filter-map
_.map(_.filter(data, 'filtering'), 'mapping')
lodash reduce
_.reduce(data, function(result, value, key) { if (value.filtering) { result.push(value.mapping) } return result; }, [])
native reduce
data.reduce(function(result, value, key) { if (value.filtering) { result.push(value.mapping) } return result; }, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native lodash filter map
Lazy Lodash filter-map
lodash reduce
native reduce

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares different ways to perform a common data processing task: filtering an array of objects based on a specific property, and then mapping each object to extract a specific value from it. The test cases use either native JavaScript methods or the Lodash library to achieve this goal.

**Script Preparation Code**

The script preparation code creates an array `data` with 1 million objects, each containing two properties: `filtering` (a boolean) and `mapping` (an integer). This data will be used as input for the test cases.

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash library (`lodash.min.js`) from a CDN. This library is used in some of the test cases.

**Test Cases**

There are four test cases:

1. **Native JavaScript Filter and Map**: This test case uses native JavaScript methods `Array.prototype.filter()` and `Array.prototype.map()` to achieve the filtering and mapping operations.
2. **Lazy Lodash Filter-Map**: This test case uses the `_.filter()` and `_.map()` functions from the Lodash library to perform the same filtering and mapping operations.
3. **Lodash Reduce**: This test case uses the `_.reduce()` function from the Lodash library to achieve a similar result, although with a different approach.
4. **Native JavaScript Reduce**: This test case uses native JavaScript methods `Array.prototype.reduce()` to achieve the filtering and mapping operations.

**Options Compared**

The benchmark compares four options:

1. Native JavaScript Filter and Map
2. Lazy Lodash Filter-Map
3. Lodash Reduce
4. Native JavaScript Reduce

**Pros and Cons of Each Approach**

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

* **Native JavaScript Filter and Map**: Pros - Efficient, lightweight, and easy to understand. Cons - Can be slower for large datasets, requires manual iteration.
* **Lazy Lodash Filter-Map**: Pros - Provides lazy evaluation, which can reduce memory usage and improve performance. Cons - Requires the Lodash library, which adds overhead and depends on external dependencies.
* **Lodash Reduce**: Pros - Provides a concise and expressive way to perform aggregations. Cons - Can be slower than native JavaScript methods due to the added abstraction.
* **Native JavaScript Reduce**: Pros - Similar to native JavaScript Filter and Map, but with a different approach. Cons - May not be as efficient for large datasets.

**Library Used**

The Lodash library is used in two test cases:

1. Lazy Lodash Filter-Map
2. Lodash Reduce

Lodash provides a set of utility functions that make common data processing tasks easier and more efficient. However, it also adds overhead due to the external dependencies and the added abstraction.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark, other than the use of `_.` notation for Lodash functions.

**Other Alternatives**

If you're looking for alternative ways to perform similar data processing tasks, consider the following options:

1. **D3.js**: A popular library for data visualization and manipulation.
2. **Underscore.js**: Another utility library that provides similar functionality to Lodash.
3. **ES6+ Features**: Modern JavaScript features like `Array.prototype.flatMap()`, `Promise.all()` , etc can also be used to achieve similar results.

In conclusion, this benchmark helps evaluate the performance of different approaches to filtering and mapping data in JavaScript. By comparing native JavaScript methods with Lodash library functions, developers can choose the most efficient approach for their specific use case.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:81.0) Gecko/20100101 Firefox/81.0

Browser/OS: Firefox 81 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
native lodash filter map	39.9 Ops/sec
Lazy Lodash filter-map	31.6 Ops/sec
lodash reduce	69.0 Ops/sec
native reduce	76.2 Ops/sec

Related benchmarks:

native lodash filter map 2dsfg (version: 0)

Comparing performance of: native lodash filter map vs Lazy Lodash filter-map vs lodash reduce vs native reduce

Created: 4 years ago by: Guest

Jump to the latest result

native lodash filter map

Lazy Lodash filter-map

lodash reduce

native reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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