Benchmark: lodash partition vs forEach with array push

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)}})

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

forEach

32K/s

Lodash partition

16K/s

Fastest: forEach (2.0x faster)

View exact numbers

✓ forEach: 31,671 ops/sec
• Lodash partition: 15,896 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash partition
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

forEach

43K/s

Lodash partition

15K/s

View exact numbers

Test name	Executions per second
✓ forEach	43,012 Ops/sec
Lodash partition	14,986 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is crucial for optimizing code and ensuring efficient execution. The provided JSON represents a benchmark test on MeasuringThat.net, comparing two approaches: using the `lodash.partition()` function versus using a custom implementation with a `forEach` loop.

**What is being tested?**

The test measures the performance of two methods:

1. **Lodash partition**: Using the `lodash.partition()` function to divide an array into two parts based on a condition.
2. **Custom forEach implementation**: Creating an array `a` and another array `b`, then using a `forEach` loop to iterate over the input array `tabl`. If an item is even, it's pushed to `a`; otherwise, it's pushed to `b`.

**Options compared**

The two options being compared are:

1. **Lodash partition**: Using the `lodash.partition()` function, which takes an array and a predicate function as arguments.
2. **Custom forEach implementation**: Creating an array-based solution using a `forEach` loop.

**Pros and Cons of each approach:**

1. **Lodash partition**:
	* Pros:
		+ High-level abstraction, making the code more readable and maintainable.
		+ Optimized for performance by using internal loop optimization techniques.
	* Cons:
		+ External dependency on the Lodash library, which may increase bundle size or have security implications.
		+ May not be suitable for very small arrays due to overhead of function calls.
2. **Custom forEach implementation**:
	* Pros:
		+ No external dependencies, reducing bundle size and potential security risks.
		+ Suitable for very small arrays without significant performance impact.
	* Cons:
		+ Requires more code maintenance and readability efforts, as it's a low-level implementation.

**Library: Lodash**

Lodash is a popular JavaScript library providing various utility functions. The `lodash.partition()` function takes two arguments:

1. An array (`tabl` in this case).
2. A predicate function (`v => v%2`) that determines the partitioning logic.

The `partition()` function returns an array containing two partitions: elements for which the predicate is true (in this case, even numbers) and elements for which the predicate is false (odd numbers).

**Special JS feature or syntax**

There's no specific JavaScript feature or syntax mentioned in this benchmark. The focus is on comparing the performance of two different implementation approaches.

**Other alternatives**

For larger-scale array processing tasks, you might consider alternative algorithms or libraries that provide optimized solutions, such as:

1. `Array.prototype.filter()` and `Array.prototype.reduce()`, which can be used together to achieve similar results.
2. `lodash.eachRight()` and `lodash.map` for iterating over arrays in reverse order or transforming elements.
3. Custom implementations using specialized data structures like Segment Trees or Suffix Arrays.

When choosing an approach, consider factors such as performance requirements, code maintainability, and the size of your input array.

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

Comparing performance of: `Lodash partition vs forEach`

Created: 7 years ago by: Registered User

Go to the latest result

Lodash partition

forEach

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

Comparing performance of: Lodash partition vs forEach

Created: 7 years ago by: Registered User

Go to the latest result

Lodash partition

forEach

Historical Performance Data aggregated from 8 community runs

Desktop Results:

Chrome 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Lodash partition vs forEach`