Benchmark: Unique and max item from array: Object.values + reduce OR lodash orderBy + uniqBy

HTML Preparation code:

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

Script Preparation code:

var test = [{
    id: 'a1',
    value: 20
}, {
    id: 'a2',
    value: 15
}, {
    id: 'a3',
    value: 40
}, {
    id: 'a1',
    value: 99
}, {
    id: 'a2',
    value: 30
}]

Tests:

Object.values + reduce
var result = Object.values(test.reduce((acc, curr) => { if (!acc[curr.id] || acc.value < curr.value) { acc[curr.id] = curr } return acc }, {}))
Lodash orderBy + uniqBy
var result = _(test).orderBy(['id', 'value'], ['asc', 'desc']).uniqBy('id').value()
Lodash map + groupBy + maxBy
var result = _.map(_.groupBy(test, 'id'), g => _.maxBy(g, 'value'))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values + reduce
Lodash orderBy + uniqBy
Lodash map + groupBy + maxBy

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

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.values + reduce	2043519.2 Ops/sec
Lodash orderBy + uniqBy	455687.0 Ops/sec
Lodash map + groupBy + maxBy	642501.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the details of the provided benchmark.

**Benchmark Overview**

The goal of this benchmark is to measure which approach is faster for removing duplicated items by ID from an array while maintaining the largest value. The test data consists of an array of objects with `id` and `value` properties.

**Options Compared**

There are three options being compared:

1. **Object.values + reduce**: This approach uses the `Object.values()` method to extract the array values, and then reduces it using the `reduce()` method.
2. **Lodash orderBy + uniqBy**: This approach uses Lodash's `orderBy()` function to sort the array by `id` in ascending order, followed by `uniqBy()` to remove duplicates based on `id`, and finally `value()` to extract the largest value.
3. **Lodash map + groupBy + maxBy**: This approach uses Lodash's `map()` function to transform each object into a new object with only `id` and `value` properties, followed by `groupBy()` to group the objects by `id`, and finally `maxBy()` to find the maximum value for each group.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Object.values + reduce**:
	* Pros: Simple and straightforward implementation.
	* Cons: May not be efficient for large datasets, as it requires multiple passes over the data.
2. **Lodash orderBy + uniqBy**:
	* Pros: Can handle large datasets efficiently, as Lodash's sorting and grouping functions are optimized.
	* Cons: Requires including Lodash in the benchmark, which may add overhead.
3. **Lodash map + groupBy + maxBy**:
	* Pros: Can be efficient for large datasets, as it uses Lodash's optimized grouping and aggregation functions.
	* Cons: May require more memory to store the intermediate results.

**Library and Syntax**

The following libraries are used in the benchmark:

1. **Lodash**: A popular utility library for JavaScript that provides various functions for array manipulation, object transformation, and data processing.
2. **Object.values()`, `reduce()`, `map()`, `groupBy()`, `maxBy()`: These are built-in JavaScript methods or functions that can be used to perform the desired operations.

There is no special JavaScript feature or syntax being tested in this benchmark.

**Alternative Approaches**

Some alternative approaches could include:

1. Using a custom implementation of the desired algorithm, without relying on built-in methods.
2. Using a different library or framework for array manipulation and data processing.
3. Optimizing the existing implementations using techniques such as caching, memoization, or parallel processing.

However, these alternatives may not be relevant to the specific problem being tested in this benchmark.

Related benchmarks:

Unique and max item from array: Object.values + reduce OR lodash orderBy + uniqBy (version: 0)

Remove duplicated items by id from list maintaining the biggest value

Comparing performance of: Object.values + reduce vs Lodash orderBy + uniqBy vs Lodash map + groupBy + maxBy

Created: 2 years ago by: Guest

Jump to the latest result

Object.values + reduce

Lodash orderBy + uniqBy

Lodash map + groupBy + maxBy

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