Benchmark: lodash/partitionBy vs native reduce

HTML Preparation code:

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

Script Preparation code:

var data = [
  { name: 'pi', value: 3.14 },
  { name: 'hundred', value: 100 },
  { name: 'truthy', value: true },
  { name: 'falsy', value: false },
  { name: 'estring', value: '2.71828' },
];

var partitionBy = (arr, key) => Object.values(arr.reduce((acc, item) => {
    var _a;
    return (Object.assign(Object.assign({}, acc), { [String(item[key])]: [...((_a = acc[String(item[key])]) !== null && _a !== void 0 ? _a : []), item] }));
}, {}));

var partitionByForEach = (array, fn) => {
  var acc = {};
  _.forEach(array, (value) => {
    acc[fn(value)] = value;
  });
  return Object.values(acc);
};

var partitionByForLoop = (array, fn) => {
  var acc = {};
  for (let i = 0; i < array.length; i++) {
    acc[fn(array[i])] = array[i];
  }
  return Object.values(acc);
};

Tests:

_.partitionBy(data, (v) => v.name);
_.partitionBy(data, (v) => v.name);
partitionBy with native reduce
partitionBy(data, (v) => v.name);
partitionBy with forEach
partitionByForEach(data, (v) => v.name);
partitionBy with for loop
partitionByForLoop(data, (v) => v.name);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.partitionBy(data, (v) => v.name);
partitionBy with native reduce
partitionBy with forEach
partitionBy with for loop

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 123 on Mac OS X 10.15.7

View result in a separate tab

partitionBy with for loop

4.6M/s

partitionBy with forEach

3.1M/s

partitionBy with native reduce

396K/s

_.partitionBy(data, (v) => v.name);

0/s

View exact numbers

Test name	Executions per second
✓ partitionBy with for loop	4,565,322 Ops/sec
partitionBy with forEach	3,115,274 Ops/sec
partitionBy with native reduce	395,743 Ops/sec
_.partitionBy(data, (v) => v.name);	0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros/cons.

**Benchmark Overview**

The benchmark compares four approaches to group data by a specific key: native reduce, `lodash/partitionBy`, `lodash/partitionByForEach`, and `lodash/partitionByForLoop`. The data being used is an array of objects with a "name" property.

**Tested Approaches**

1. **Native Reduce**: Uses the built-in `reduce()` method to group data by the specified key.
2. **`lodash/partitionBy`**: A utility function from the popular JavaScript library Lodash that groups data by a specific key.
3. **`lodash/partitionByForEach`**: Another utility function from Lodash that groups data by a specific key using `forEach`.
4. **`lodash/partitionByForLoop`**: Yet another utility function from Lodash that groups data by a specific key using a for loop.

**Options Compared**

The benchmark compares the performance of each approach on a fixed dataset with a specified key (`"name"`).

**Pros and Cons:**

1. **Native Reduce**:
	* Pros: Fast, efficient, and widely supported.
	* Cons: Requires understanding of the `reduce()` method, which can be complex for beginners.
2. **`lodash/partitionBy`**:
	* Pros: Easy to use, readable, and well-documented. Lodash is a popular library with a large community.
	* Cons: Adds overhead due to the library's existence and imports. May not be suitable for projects with strict size constraints.
3. **`lodash/partitionByForEach`**:
	* Pros: Similar to `partitionBy`, but uses `forEach` instead of Lodash's built-in functions. Can be more readable in some cases.
	* Cons: Still adds overhead due to the library's existence and imports.
4. **`lodash/partitionByForLoop`**:
	* Pros: Simple, easy to understand, and can be more efficient than `partitionByForEach`.
	* Cons: May be less readable than other approaches, especially for complex scenarios.

**Library Use**

In all cases, the benchmark uses Lodash's `partitionBy`, `partitionByForEach`, and `partitionByForLoop` functions. These libraries are popular choices for JavaScript developers due to their extensive feature sets and well-documented APIs.

**Special JS Feature or Syntax**

None of the tested approaches rely on special JavaScript features or syntax that would be specific to a particular browser or engine version.

**Other Alternatives**

If you don't want to use Lodash, you can implement your own grouping logic using native JavaScript functions like `reduce()`, `forEach()`, and object iteration. Alternatively, you can explore other libraries that offer similar functionality, such as Moment.js for date manipulation or Ramda.js for functional programming utilities.

The benchmark's focus on comparing the performance of different approaches makes it an excellent resource for understanding the trade-offs involved in choosing a specific grouping method.

lodash/partitionBy vs native reduce (version: 0) Benchmark.js

Comparing performance of: `_.partitionBy(data, (v) => v.name); vs partitionBy with native reduce vs partitionBy with forEach vs partitionBy with for loop`

Created: 2 years ago by: Guest

Go to the latest result

_.partitionBy(data, (v) => v.name);

partitionBy with native reduce

partitionBy with forEach

partitionBy with for loop

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

lodash/partitionBy vs native reduce (version: 0) Benchmark.js

Comparing performance of: _.partitionBy(data, (v) => v.name); vs partitionBy with native reduce vs partitionBy with forEach vs partitionBy with for loop

Created: 2 years ago by: Guest

Go to the latest result

_.partitionBy(data, (v) => v.name);

partitionBy with native reduce

partitionBy with forEach

partitionBy with for loop

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: `_.partitionBy(data, (v) => v.name); vs partitionBy with native reduce vs partitionBy with forEach vs partitionBy with for loop`