Benchmark: Lazy array chains: no benefit for simple non-stupid ops

Lazy array chains: no benefit for simple non-stupid ops (version: 1)

Comparing performance of: array method chain (1000 items) vs lazy chain (1000 items) vs array method chain (10000 items) vs lazy chain (10000 items) vs array method chain (100000 items) vs lazy chain (100000 items) vs array method chain with 2 filters - stupid! (1000 items) vs lazy chain with 2 filters (1000 items) vs array method chain with 2 filters - stupid! (10000 items) vs lazy chain with 2 filters (10000 items)

Created: 3 months ago by: Guest

Jump to the latest result

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><!--your preparation HTML code goes here-->

Script Preparation code:

const LCG = (s) => () => (s = (48271 * s) % 2147483647) / 2147483647;
const rand = LCG(123);
const dataS = Array.from({length: 1000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));
const dataM = Array.from({length: 10000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));
const dataL = Array.from({length: 100000}, () => ({ a: rand() > 0.5 ? 'abcd' : 'abcdefg', b: 50 * rand(), c: ['an', 'array'] }));

const filterFn = data => data.a === 'abcdefg';
const filterFn2 = data => data.b < 25;
const mapFn = data => ({...data, d: [...data.c, data.b.toString()]});

Tests:

array method chain (1000 items)
const mapped = dataS.filter(filterFn).map(mapFn);
lazy chain (1000 items)
const mapped = _.chain(dataS).filter(filterFn).map(mapFn).value();
array method chain (10000 items)
const mapped = dataM.filter(filterFn).map(mapFn);
lazy chain (10000 items)
const mapped = _.chain(dataM).filter(filterFn).map(mapFn).value();
array method chain (100000 items)
const mapped = dataL.filter(filterFn).map(mapFn);
lazy chain (100000 items)
const mapped = _.chain(dataL).filter(filterFn).map(mapFn).value();
array method chain with 2 filters - stupid! (1000 items)
const mapped = dataS.filter(filterFn).filter(filterFn2).map(mapFn);
lazy chain with 2 filters (1000 items)
const mapped = _.chain(dataS).filter(filterFn).filter(filterFn2).map(mapFn).value();
array method chain with 2 filters - stupid! (10000 items)
const mapped = dataM.filter(filterFn).filter(filterFn2).map(mapFn);
lazy chain with 2 filters (10000 items)
const mapped = _.chain(dataM).filter(filterFn).filter(filterFn2).map(mapFn).value();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array method chain (1000 items)
lazy chain (1000 items)
array method chain (10000 items)
lazy chain (10000 items)
array method chain (100000 items)
lazy chain (100000 items)
array method chain with 2 filters - stupid! (1000 items)
lazy chain with 2 filters (1000 items)
array method chain with 2 filters - stupid! (10000 items)
lazy chain with 2 filters (10000 items)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Firefox 134 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
array method chain (1000 items)	11413.1 Ops/sec
lazy chain (1000 items)	11226.6 Ops/sec
array method chain (10000 items)	1068.6 Ops/sec
lazy chain (10000 items)	1067.4 Ops/sec
array method chain (100000 items)	58.6 Ops/sec
lazy chain (100000 items)	52.8 Ops/sec
array method chain with 2 filters - stupid! (1000 items)	16150.1 Ops/sec
lazy chain with 2 filters (1000 items)	17254.6 Ops/sec
array method chain with 2 filters - stupid! (10000 items)	1695.3 Ops/sec
lazy chain with 2 filters (10000 items)	1723.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark tests two approaches to processing arrays of objects in JavaScript using the `filter` and `map` methods. It compares "traditional array method chaining" with "lazy evaluation" using the Lodash library.

### Arrays and Data Generation

Three datasets are generated with varying sizes: 1000, 10000, and 100000 items. Each object in the arrays contains the following keys:
- **`a`**: A string that can either be `'abcd'` or `'abcdefg'`, randomly assigned.
- **`b`**: A random number between 0 and 50.
- **`c`**: An array containing a string `'an'` and another string `'array'`.

The datasets are named:
- `dataS`: 1000 items
- `dataM`: 10000 items
- `dataL`: 100000 items

### Filtering and Mapping Functions

The benchmark uses two filtering functions and one mapping function:
- **Filtering Functions**:
  - **`filterFn`**: Filters objects where `a` is equal to `'abcdefg'`.
  - **`filterFn2`**: Filters objects where `b` is less than 25.
  
- **Mapping Function**:
  - **`mapFn`**: Adds a new property `d` to the object by merging the existing properties with an array derived from property `c` and the string representation of property `b`.

### Approaches Compared

#### 1. Traditional Array Method Chaining
```
const mapped = dataS.filter(filterFn).map(mapFn);
```
- **Description**: Uses native JavaScript array methods `filter` and `map` directly in a chaining fashion.
- **Pros**:
  - Native methods are optimized for performance in modern JavaScript engines.
  - More straightforward syntax with no additional library dependencies.
- **Cons**:
  - Each method call returns a new array, consuming memory and processing time, especially with larger datasets.

#### 2. Lazy Evaluation with Lodash
```
const mapped = _.chain(dataS).filter(filterFn).map(mapFn).value();
```
- **Description**: Utilizes Lodash's `chain()` method to process the array in a lazy manner, where intermediate results are not stored until `.value()` is called.
- **Pros**:
  - Potentially more efficient for large datasets because it avoids creating intermediate arrays for every operation.
  - Includes more utility functions and can simplify complex data manipulations.
- **Cons**:
  - Requires loading an external library (Lodash), which may add overhead in terms of bundle size and dependency management.
  - Some find the syntax less intuitive than native methods.

### Test Cases

The benchmark includes multiple test cases that vary in dataset size and the number of filter operations applied:

1. **Simple Cases**:
   - Array method chaining vs. lazy chaining for datasets of sizes 1000, 10000, and 100000.
   
2. **Chained Filters**:
   - The test also evaluates cases where two filters are applied in succession. These are labeled as "stupid" in comments, likely reflecting the inefficiency of filtering twice sequentially when a combined condition would suffice.

### Benchmark Results

The results indicate the number of executions per second for each test case executed in the same environment, allowing comparisons between approaches:
- For datasets of 1000 items, lazy chaining outperformed regular chain for multiple filters.
- As the dataset size increases to 100000, performance in both approaches drops significantly, though the lazy chain generally exhibited slightly lower execution rates, indicating the overhead that comes from chaining.

### Alternatives Considered

1. **Native Map and Filter**: Directly using the built-in methods provides simplicity and frequent performance optimization in JavaScript.
2. **Functional Libraries (e.g., Ramda)**: Like Lodash, these libraries offer lazy evaluations and additional utility functions but come with their own base size overhead.
3. **For-Loop or Reduce**: Implementing transformations in basic for-loops or using the `reduce` method may yield better performance in some cases, especially with very specific transformations.

### Conclusion

In the end, the choice between traditional array method chaining and using a library for lazy evaluation largely depends on the specific use case, the size of the datasets involved, and considerations around performance, clarity, and code maintainability. Both approaches have their advantages, but the best choice will typically hinge on the specific requirements of the application being developed.

Related benchmarks:

Lazy array chains: no benefit for simple non-stupid ops (version: 1)

Created: 3 months ago by: Guest

Jump to the latest result

array method chain (1000 items)

lazy chain (1000 items)

array method chain (10000 items)

lazy chain (10000 items)

array method chain (100000 items)

lazy chain (100000 items)

array method chain with 2 filters - stupid! (1000 items)

lazy chain with 2 filters (1000 items)

array method chain with 2 filters - stupid! (10000 items)

lazy chain with 2 filters (10000 items)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):