Benchmark: Lodash partition vs ES6 for..of partition

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var arr = [
  { name: 'john', hasPet: true },
  { name: 'jack', hasPet: false },
  { name: 'jill', hasPet: false },
  { name: 'james', hasPet: true },
  { name: 'jane', hasPet: false },
]

Tests:

_.partition
_.partition(arr, el => el.hasPet);
ES6 partition with for..of
const partition = (arr, fun) => { const positive = []; const negative = []; for (el of arr) { if (el.hasPet) { positive.push(el); } else { negative.push(el); } } return [positive, negative]; }; partition(arr, el => el.hasPet);
ES partition with filter
const partition = (arr, fun) => { const positive = arr.filter(fun); const negative = arr.filter(el => !fun(el)); return [positive, negative]; }; partition(arr, el => el.hasPet);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.partition
ES6 partition with for..of
ES partition with filter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark test case that compares three approaches to partition an array in JavaScript: using Lodash's `partition` function, implementing a custom `partition` function with a for...of loop, and another custom implementation with the Array.prototype.filter() method.

**Options Compared**

1. **Lodash `partition`**: This approach uses the built-in `partition` function from the Lodash library.
2. **ES6 Partition with for...of Loop**: This implementation creates two arrays (`positive` and `negative`) using a for...of loop, filtering elements based on the condition provided as an argument.
3. **ES Partition with filter()**: This approach uses Array.prototype.filter() to create two separate arrays: one containing elements that pass the test (positive) and another containing elements that fail (negative).

**Pros and Cons**

1. **Lodash `partition`**:
	* Pros: Built-in function, concise code, easy to read.
	* Cons: Requires an external dependency (Lodash), may not be optimal for small arrays due to the overhead of the library.
2. **ES6 Partition with for...of Loop**:
	* Pros: Directly controls execution flow, no external dependencies, can be more efficient for small arrays.
	* Cons: More verbose code, requires understanding of for...of loops and array iteration.
3. **ES Partition with filter()**:
	* Pros: Widely supported and well-understood, easy to read, can be more efficient than Lodash's partition function.
	* Cons: Requires two separate calls to filter(), which might not be as straightforward as a single call.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a collection of functions for various tasks, such as array manipulation, object manipulation, and more. In this case, the `partition` function is used to create two arrays from an input array based on a predicate (a test function).

**Special JS Feature/Syntax: for...of Loop**

The ES6 Partition with for...of Loop implementation uses a modern JavaScript feature called the for...of loop. This syntax allows you to iterate over arrays and other iterable objects in a more concise and expressive way.

**Alternative Approaches**

Other approaches to partitioning an array might include:

1. Using Array.prototype.every() and Array.prototype.some() to create two separate arrays.
2. Implementing a custom partition function using recursion or other iteration techniques.
3. Utilizing specialized libraries like Ramda or Liskell for functional programming tasks.

Keep in mind that the best approach depends on the specific use case, performance requirements, and personal preference.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
_.partition	3683215.0 Ops/sec
ES6 partition with for..of	442908.6 Ops/sec
ES partition with filter	5541656.0 Ops/sec

Related benchmarks:

Lodash partition vs ES6 for..of partition (version: 0)

Comparison of using lodash partition against raw ES6 using for..of loop

Comparing performance of: _.partition vs ES6 partition with for..of vs ES partition with filter

Created: one year ago by: Registered User

Jump to the latest result

_.partition

ES6 partition with for..of

ES partition with filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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