Benchmark: lodash partition vs forEach with array push vs two filter loops

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var tabl = Array.from({ length: 10000 }).map((value, i) => i)

Tests:

Lodash partition
let result = _.partition(tabl, v => v%2)
forEach
let a = [], b = []; let result = tabl.forEach(item => {if (item%2) {a.push(item)} else {b.push(item)}})
double filter
const a = tabl.filter(item => item%2); const b = tabl.filter(item => !item%2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash partition
forEach
double filter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition json and explain what's being tested.

The test is designed to compare three approaches for filtering an array in JavaScript:

1. **Lodash `partition` method**: This approach uses the `partition` function from the Lodash library, which splits the array into two parts: one containing elements that pass a certain condition (in this case, `v => v % 2 == 0`) and another containing elements that do not.
2. **`forEach` loop with array push**: This approach uses a traditional `forEach` loop to iterate over the array and push elements into two separate arrays (`a` and `b`) based on whether they meet the condition.
3. **Double filter loops**: This approach uses two separate `filter` methods to create two new arrays, one containing elements that pass the condition and another containing elements that do not.

**Pros and Cons of each approach:**

* Lodash `partition` method:
	+ Pros: Efficient and concise, eliminates the need for explicit loop variables.
	+ Cons: Relies on an external library (Lodash), may be less familiar to those without experience with functional programming.
* `forEach` loop with array push:
	+ Pros: Easy to understand and implement, no external dependencies required.
	+ Cons: Less efficient than `partition`, can lead to slower performance due to the overhead of creating new arrays.
* Double filter loops:
	+ Pros: No external dependencies required, easy to understand and implement.
	+ Cons: Can be less concise and more verbose than `partition` or `forEach` loop, may require additional array manipulation.

**Library usage:** The Lodash library is used for the `partition` method. This library provides a set of utility functions for tasks such as array manipulation, string manipulation, and functional programming.

**Special JS features or syntax:** None are mentioned in this benchmark definition. However, it's worth noting that some modern JavaScript features like async/await, classes, and modules (ES6+) may be used in the script preparation code or other test cases.

**Other alternatives:** Some alternative approaches to filtering an array could include:

* Using `Array.prototype.filter()` method directly on the original array.
* Using a regular expression with `String.prototype.match()` and `Array.prototype.push()`.
* Using a custom implementation using bitwise operations or other low-level techniques.

Keep in mind that each of these alternatives may have their own trade-offs in terms of performance, readability, and maintainability.

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Linux

View result in a separate tab

Test name	Executions per second
Lodash partition	14064.9 Ops/sec
forEach	29963.0 Ops/sec
double filter	26141.8 Ops/sec

Related benchmarks:

lodash partition vs forEach with array push vs two filter loops (version: 0)

Comparing performance of: Lodash partition vs forEach vs double filter

Created: 5 years ago by: Guest

Jump to the latest result

Lodash partition

forEach

double filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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