Benchmark: lodash partition vs forEach with array push vs two segregated push with "some" ordered 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 indexTbl = Array.from({ length: 50 }).map((value, i) => Math.ceil(Math.random()*1000));
var sortedIndexTbl = indexTbl.sort((a,b)=>a - b);
var tabl = Array.from({ length: 1000000 }).map((value, i) => i);

Tests:

Lodash partition - Unsorted
let result = _.partition(tabl, v => indexTbl.some(i=>i==v))
forEach
let a = [], b = []; let result = tabl.forEach(item => {if (indexTbl.some(i=>i==item)) {a.push(item)} else {b.push(item)}})
double filter
const a = tabl.filter(item => indexTbl.some(i=>i==item)); const b = tabl.filter(item => !indexTbl.some(i=>i==item));
Lodash partition - Sorted
let result = _.partition(tabl, v => sortedIndexTbl.some(i=>i==v));
forEach - sorted
let a = [], b = []; let result = tabl.forEach(item => {if (sortedIndexTbl.some(i=>i==item)) {a.push(item)} else {b.push(item)}})
doublefilter - sorted
const a = tabl.filter(item => sortedIndexTbl.some(i=>i==item)); const b = tabl.filter(item => !sortedIndexTbl.some(i=>i==item));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash partition - Unsorted
forEach
double filter
Lodash partition - Sorted
forEach - sorted
doublefilter - sorted

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarks!

**Overview**

MeasureThat.net provides a platform for comparing the performance of different approaches to achieve similar results in JavaScript. The provided benchmark tests various ways to partition an array, which involves dividing it into two parts based on some condition.

**Benchmark Definition JSON**

The JSON represents a single benchmark definition, but there are multiple test cases defined separately. Let's focus on one test case and then generalize the approach.

**Test Case: Lodash Partition - Unsorted**

The `Benchmark Definition` is:
```javascript
let result = _.partition(tabl, v => indexTbl.some(i=>i==v));
```
This line of code uses the `_` (Lodash) library to partition an array `tabl` into two parts based on a condition. The condition checks if any element in `indexTbl` is equal to the current element `v` in `tabl`. If so, it includes `v` in the first part; otherwise, it includes `v` in the second part.

**Options Compared**

The benchmark compares four options:

1. **Lodash Partition**: Uses the `_partition()` function from Lodash.
2. **forEach with Array Push**: Iterates over the array using `forEach`, pushing elements to two separate arrays based on the condition.
3. **Two Segregated Push with "some" Ordered Filter Loops**: Similar to option 2, but uses two separate push operations and an ordered filter loop.

**Pros and Cons**

1. **Lodash Partition**:
	* Pros: concise and expressive code, optimized for performance by Lodash.
	* Cons: relies on the Lodash library, which may introduce overhead for some users.
2. **forEach with Array Push**:
	* Pros: can be easier to understand and implement for developers familiar with `forEach`.
	* Cons: less efficient than Lodash Partition due to repeated push operations and iteration over the array.
3. **Two Segregated Push with "some" Ordered Filter Loops**:
	* Pros: similar to option 2, but with two separate push operations and an ordered filter loop, which can be beneficial for performance.
	* Cons: more complex code and potentially slower due to the additional operations.

**Library and Purpose**

Lodash is a popular JavaScript library that provides a wide range of utility functions. In this case, `_partition()` is used to divide an array into two parts based on a condition.

**Special JS Features or Syntax**

None mentioned in the provided benchmark definition.

**Other Alternatives**

If you're interested in exploring alternative approaches to partitioning an array, consider:

1. `Array.prototype.filter()`: Similar to the `forEach` with Array Push approach, but using the built-in `filter()` method.
2. `Set` and `Map` data structures: Using sets or maps to store elements that meet a certain condition can provide efficient lookup and partitioning capabilities.

Keep in mind that performance optimizations often involve trade-offs between code readability, maintainability, and efficiency. The choice of approach depends on the specific use case, personal preference, and performance requirements.

Related benchmarks:

lodash partition vs forEach with array push vs two segregated push with "some" ordered filter loops (version: 0)

Comparing performance of: Lodash partition - Unsorted vs forEach vs double filter vs Lodash partition - Sorted vs forEach - sorted vs doublefilter - sorted

Created: 4 years ago by: Registered User

Jump to the latest result

Lodash partition - Unsorted

forEach

double filter

Lodash partition - Sorted

forEach - sorted

doublefilter - sorted

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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