Benchmark: lodash partition vs forEach with array spread iterator vs array push vs for each with concat vs two filters with 10000

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 with push
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]}})
forEach with concat
let a = [], b = []; let result = tabl.forEach(item => {if (item%2) {a = a.concat(item)} else {b = b.concat(item)}})
two filters
a = tabl.filter(item => item % 2) 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 with push
forEach with spread
forEach with concat
two filters

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 JavaScript microbenchmarking results.

**Benchmark Overview**

The provided benchmark compares the performance of different approaches to manipulate arrays in JavaScript:

1. `lodash partition`
2. `forEach` with `push`
3. `forEach` with spread (`...`)
4. `forEach` with `concat`
5. Two separate filters using `filter`

**Lodash Partition**

The first test case uses Lodash's `partition` function to split an array into two parts based on a condition.

Pros:

* Easy to read and write
* Concise code

Cons:

* Lodash is a external library, which might introduce overhead.
* The `partition` function creates new arrays, which can lead to higher memory usage.

**forEach with Push**

The second test case uses the `forEach` method with `push` to create two separate arrays based on the condition.

Pros:

* No additional libraries needed
* Simple and straightforward code

Cons:

* Can be less efficient due to the overhead of creating new arrays.
* More verbose than the Lodash solution.

**forEach with Spread**

The third test case uses the spread operator (`...`) with `forEach` to create two separate arrays based on the condition.

Pros:

* No additional libraries needed
* Concise and modern syntax

Cons:

* Not all older browsers support the spread operator.
* Can be less efficient due to the overhead of creating new arrays.

**forEach with Concat**

The fourth test case uses the `concat` method with `forEach` to create two separate arrays based on the condition.

Pros:

* No additional libraries needed
* Simple and straightforward code

Cons:

* Can be less efficient due to the overhead of creating new arrays.
* Less modern syntax than using spread or push.

**Two Filters**

The fifth test case uses two separate filters (`filter`) to create two separate arrays based on the condition.

Pros:

* No additional libraries needed
* Simple and straightforward code

Cons:

* Can be less efficient due to the overhead of creating new arrays.
* More verbose than using `forEach` with push or spread.

**Other Considerations**

When choosing a method for array manipulation, consider factors like performance, memory usage, and maintainability. In general:

* When speed is critical, use methods that minimize object creation (e.g., `forEach` with `push`, two filters).
* When code readability is important, choose methods with clear and concise syntax (e.g., Lodash `partition`).
* When using a library is acceptable, consider its overhead and trade-offs.

**Alternatives**

If you're interested in exploring alternative approaches:

1. **Array.prototype.reduce()**: Instead of `forEach`, use `reduce()` to accumulate results.
2. **Array.prototype.map()**: Use `map()` to create new arrays with transformed values.
3. **For loops**: Consider using traditional for loops instead of `forEach` or `map`.
4. **ES6 features**: Experiment with newer ES6 features like destructuring, arrow functions, and async/await.

Keep in mind that each alternative has its own trade-offs and might not be suitable for every use case.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; M2102J20SG) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.5481.192 Mobile Safari/537.36 OPR/74.1.3922.71199

Browser/OS: Opera Mobile 74 on Android

View result in a separate tab

Test name	Executions per second
Lodash partition	8334.3 Ops/sec
forEach with push	11641.5 Ops/sec
forEach with spread	19.7 Ops/sec
forEach with concat	4.2 Ops/sec
two filters	6952.4 Ops/sec

Related benchmarks:

lodash partition vs forEach with array spread iterator vs array push vs for each with concat vs two filters with 10000 (version: 0)

Comparing performance of: Lodash partition vs forEach with push vs forEach with spread vs forEach with concat vs two filters

Created: one year ago by: Guest

Jump to the latest result

Lodash partition

forEach with push

forEach with spread

forEach with concat

two filters

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