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

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

forEach with push

34K/s

Lodash partition

25K/s

two filters

24K/s

forEach with spread

58/s

forEach with concat

15/s

View exact numbers

Test name	Executions per second
✓ forEach with push	33,878 Ops/sec
Lodash partition	25,208 Ops/sec
two filters	24,349 Ops/sec
forEach with spread	58 Ops/sec
forEach with concat	15 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 3 years ago by: Guest

Go to the latest result

Lodash partition

forEach with push

forEach with spread

forEach with concat

two filters

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 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: 3 years ago by: Guest

Go to the latest result

Lodash partition

forEach with push

forEach with spread

forEach with concat

two filters

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 with push vs forEach with spread vs forEach with concat vs two filters`