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

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

Latest run results:

Run details: (Test run date: 7 months 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

Test name	Executions per second
_.partitionBy(data, (v) => v.name);	0.0 Ops/sec
partitionBy with native reduce	395742.8 Ops/sec
partitionBy with forEach	3115273.5 Ops/sec
partitionBy with for loop	4565321.5 Ops/sec

Related benchmarks:

lodash/partitionBy vs native reduce (version: 0)

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

Created: 7 months ago by: Guest

Jump 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>

Experimental features:

Fastest: N/A

Slowest: N/A

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