Benchmark: lodash partition vs forEach with array spread iterator vs 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)}})
forEach with spread
let a = [], b = []; let result = tabl.forEach(item => {if (item%2) {a = [...a, item]} else {b = [...b, item]}})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash partition
forEach
forEach with spread

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested?**

The provided benchmark measures the performance of three different approaches for partitioning an array:

1. **Lodash `partition` method**: This function takes two arguments: the input array and a callback function that determines which elements to include in the resulting arrays.
2. **JavaScript `forEach` loop with array push**: This approach uses a traditional `forEach` loop to iterate over the array, pushing elements into separate arrays based on their value modulo 2.
3. **JavaScript `forEach` loop with array spread and iteration**: This variant of the previous approach uses the spread operator (`...`) to create new arrays and iterates using a separate variable.

**Options compared**

The benchmark compares three approaches:

* Lodash `partition`: A well-established, optimized function for partitioning arrays.
* JavaScript `forEach` loop with array push: A basic, straightforward approach that is easy to understand but may not be optimized.
* JavaScript `forEach` loop with array spread and iteration: An alternative approach that uses the spread operator to create new arrays and iterates using a separate variable.

**Pros and Cons**

Here's a brief summary of each approach:

1. **Lodash `partition` method**
	* Pros:
		+ Optimized for performance
		+ Handles edge cases (e.g., empty arrays)
		+ Partitions the array in-place, which can be beneficial for large datasets.
	* Cons:
		+ Requires an additional library (Lodash) to use
		+ May have a higher memory overhead due to the in-place partitioning
2. **JavaScript `forEach` loop with array push**
	* Pros:
		+ Easy to understand and implement
		+ No additional libraries required
	* Cons:
		+ Less optimized than Lodash's `partition` method
		+ May require more memory due to the creation of multiple arrays
3. **JavaScript `forEach` loop with array spread and iteration**
	* Pros:
		+ Reduces memory overhead compared to `push`
		+ Still relatively easy to understand and implement
	* Cons:
		+ Requires using the spread operator (`...`), which can be unfamiliar for some developers

**Library usage**

The Lodash `partition` method uses the **Lodash library**, a popular utility library that provides various functions for tasks like array manipulation, string manipulation, and more.

**Special JavaScript feature or syntax**

The benchmark doesn't use any special JavaScript features or syntax beyond the standard `forEach` loop and spread operator (`...`). However, it does rely on modern JavaScript features like arrow functions (`=>`) and template literals (`<script>...</script>`).

**Other alternatives**

If you're interested in exploring alternative approaches for partitioning arrays, here are a few options:

* **Array.prototype.filter()**: This method can be used to create two separate arrays based on a callback function.
* **Reducing functions**: You can use reducing functions (e.g., `reduce()` or `reduceRight()`) to iterate over the array and accumulate results in two separate arrays.
* **Custom loops**: If you prefer a more low-level approach, you can write custom loops using traditional `for` loops or other iteration techniques.

Keep in mind that these alternatives may not be as optimized or efficient as Lodash's `partition` method or the JavaScript `forEach` loop with array spread and iteration.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Windows

View result in a separate tab

Test name	Executions per second
Lodash partition	8760.6 Ops/sec
forEach	20229.2 Ops/sec
forEach with spread	23.7 Ops/sec

Related benchmarks:

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

Comparing performance of: Lodash partition vs forEach vs forEach with spread

Created: one year ago by: Guest

Jump to the latest result

Lodash partition

forEach

forEach with spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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