Benchmark: Lodash Chain vs Native vs Lodash && vs Native && vs Flow

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script>

Script Preparation code:

var data = Array(10000000).fill({ a: 'a', b: 1 });

Tests:

Chain
_.chain(data).filter(f => f.a === 'a').filter(f => f.b === 1).filter(f => f.b + 1 === 2).map(f => f.a).filter(f => f === 'a').value()
Native (with &&)
data.filter(f => f.a === 'a' && f.b === 1 && f.b + 1 === 2).map(f => f.a).filter(f => f === 'a')
Native
data.filter(f => f.a === 'a').filter(f => f.b === 1).filter(f => f.b + 1 === 2).map(f => f.a).filter(f => f === 'a')
Flow
_.flow( _.filter(f => f.a === 'a'), _.filter(f => f.b === 1), _.filter(f => f.b + 1 === 2), _.map(f => f.a), _.filter(f => f === 'a') )(data)
Chain (with &&)
_.chain(data).filter(f => f.a === 'a' && f.b === 1 && f.b + 1 === 2).map(f => f.a).filter(f => f === 'a').value()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Chain
Native (with &&)
Native
Flow
Chain (with &&)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Windows

View result in a separate tab

Test name	Executions per second
Chain	0.5 Ops/sec
Native (with &&)	1.0 Ops/sec
Native	0.6 Ops/sec
Flow	0.5 Ops/sec
Chain (with &&)	0.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 15 days ago):

LLMs can make mistakes. Check important info.

The benchmark defined by the provided JSON tests the performance of various approaches to filter and map through a large dataset (10 million objects) using different methods: Lodash chaining, native JavaScript methods, and a functional composition method provided by Lodash's `flow` function.

### Options Compared

1. **Lodash Chain**: 
   ```javascript
   _.chain(data).filter(f => f.a === 'a').filter(f => f.b === 1).filter(f => f.b + 1 === 2).map(f => f.a).filter(f => f === 'a').value()
   ```
   - **Pros**: 
     - Provides a fluent interface that can enhance the readability of the code by allowing method chaining.
     - Allows for a more declarative style where each transformation step can be clearly expressed.
   - **Cons**: 
     - Generally has some overhead due to method chaining and maintaining internal state.
     - Can result in slower performance compared to native approaches when not optimized.

2. **Native with `&&`**:
   ```javascript
   data.filter(f => f.a === 'a' && f.b === 1 && f.b + 1 === 2).map(f => f.a).filter(f => f === 'a')
   ```
   - **Pros**:
     - Utilizes native JavaScript methods which can be highly optimized by modern JavaScript engines.
     - Reduces the complexity of chaining operations, leading to potentially better performance.
   - **Cons**: 
     - The condition within the filter is less modular and can become hard to read if too complex.
     
3. **Native**:
   ```javascript
   data.filter(f => f.a === 'a').filter(f => f.b === 1).filter(f => f.b + 1 === 2).map(f => f.a).filter(f => f === 'a')
   ```
   - **Pros**: 
     - Similar to the `&&` approach, it leverages native methods which are likely faster due to optimizations.
     - Each filtering step maintains clarity.
   - **Cons**:
     - The chaining of methods can make the code longer and potentially less readable compared to a single filter with combined conditions.

4. **Lodash Flow**:
   ```javascript
   _.flow(
     _.filter(f => f.a === 'a'),
     _.filter(f => f.b === 1),
     _.filter(f => f.b + 1 === 2),
     _.map(f => f.a),
     _.filter(f => f === 'a')
   )(data)
   ```
   - **Pros**:
     - Promotes a functional programming style, making the logic clear and modular.
     - Each function can be easily tested in isolation.
   - **Cons**:
     - Adds overhead of function calls, which might lead to slower execution than the flat native method.
     - Requires familiarity with functional programming paradigms, which may be a barrier for some developers.

5. **Lodash Chain with `&&`**:
   ```javascript
   _.chain(data).filter(f => f.a === 'a' && f.b === 1 && f.b + 1 === 2).map(f => f.a).filter(f => f === 'a').value()
   ```
   - **Pros**:
     - Combines the readability benefits of chaining with the conciseness of a single filter condition.
   - **Cons**:
     - Still carries the performance overhead compared to plain native methods.

### Benchmark Results
From the results:
- The "Chain (with &&)" variant using Lodash chained method had the highest execution speed at approximately **3.28 executions per second**.
- The native method using `&&` was slightly slower at **3.13 executions per second**.
- The standard chained native calls had lower performance at about **1.75 executions per second**, indicating that method chaining introduces overhead.
- The Lodash `flow` method performed the slowest out of all tests at **1.68 executions per second**.

### Alternatives
When considering alternatives for data manipulation in JavaScript, the following can be noted:
- **Vanilla JavaScript**: Directly using the built-in methods (`map`, `filter`, etc.) is generally recommended for small datasets or when performance is critical.
- **Immutable.js**: This library provides persistent data structures and may offer efficient performance for operations on large collections.
- **RxJS**: For reactive programming, RxJS can handle complex operations over streams of data in a more declarative style, though it comes with its own learning curve.

Overall, the choice between using Lodash versus native JavaScript should consider factors such as code readability, performance requirements, and team familiarity with functional programming.

Related benchmarks:

Lodash Chain vs Native vs Lodash && vs Native && vs Flow (version: 1)

Comparing performance of: Chain vs Native (with &&) vs Native vs Flow vs Chain (with &&)

Created: 15 days ago by: Guest

Jump to the latest result

Chain

Native (with &&)

Native

Flow

Chain (with &&)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 15 days ago):