Benchmark: reduce-vs-uniqBy 1234

HTML Preparation code:

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

Script Preparation code:

var workOrders = _.range(_.random(100)).map(x => ({
  assignee: {
    id: _.random(1, 10),
  },
}));

Tests:

Array.prototype.reduce()
workOrders.reduce((accumulator, workOrder) => { if (workOrder.assignee === null) { return accumulator; } const assigneeExists = accumulator[1].has(workOrder.assignee.id); if (assigneeExists) return accumulator; accumulator[1].add(workOrder.assignee.id); accumulator[0].push(workOrder.assignee); return accumulator; }, [[], new Set()]);
_.uniqBy
_(workOrders).map('assignee').filter().uniqBy('id').value();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.reduce()
_.uniqBy

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; rv:96.0) Gecko/20100101 Firefox/96.0

Browser/OS: Firefox 96 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Array.prototype.reduce()	341841.9 Ops/sec
_.uniqBy	122037.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, comparing different approaches to solve a specific problem or achieve a particular performance goal.

The provided benchmark definition and test cases are designed to compare two approaches: using the `Array.prototype.reduce()` method versus using the `_` library's `uniqBy()` function. The benchmark aims to extract unique items from an array of objects, with each object containing an "assignee" property.

**Options Compared**

Two options are compared:

1. **`Array.prototype.reduce()`**: This is a built-in JavaScript method that applies a reduction function to an array.
2. **_._uniqBy() _**: This is a function from the `_` library, which is a utility belt for functional programming in JavaScript.

**Pros and Cons**

### `Array.prototype.reduce()`

Pros:

* Built-in, widely supported, and optimized by browsers.
* Allows for more control over the reduction process (e.g., filtering, sorting).

Cons:

* Can be slower than other approaches due to its overhead and potential recursive function calls.
* Requires more code and complexity compared to `_._uniqBy()`.

### _._uniqBy()

Pros:

* Part of a well-established library with optimized implementations.
* Often faster and more efficient than `Array.prototype.reduce()`, especially for large datasets.
* Allows for concise, declarative code.

Cons:

* Requires the addition of an external library, which may incur overhead.
* May not be as widely supported or optimized by browsers compared to built-in methods.

**Library: _**

The `_` library is a popular utility belt for functional programming in JavaScript. It provides a set of functions that can be used to simplify and improve code quality, such as `uniqBy()`, `map()`, `filter()`, and more. The library is designed to work seamlessly with other libraries and frameworks, making it a valuable tool for developers.

**Special JS Feature or Syntax**

There doesn't seem to be any special JavaScript feature or syntax used in this benchmark. However, the use of `_` implies familiarity with functional programming concepts and the _ library.

**Other Alternatives**

If you're interested in exploring other approaches to achieve similar performance goals, consider the following alternatives:

1. **Use a different sorting algorithm**: Instead of using `Array.prototype.reduce()` or `_._uniqBy()`, try implementing a custom sorting algorithm (e.g., insertion sort, merge sort) and measuring its performance.
2. **Levenshtein distance**: Use Levenshtein distance to measure the difference between two strings (in this case, "assignee.id"). This can be more efficient than string equality checks for certain use cases.
3. **Use a data structure optimized for uniqueness**: If you need to store unique values in an array or object, consider using a data structure like a set or a map, which are optimized for fast lookups and insertions.

Keep in mind that the best approach depends on your specific requirements and performance constraints.

Related benchmarks:

reduce-vs-uniqBy 1234 (version: 0)

Compare different ways of extracting unique items

Comparing performance of: Array.prototype.reduce() vs _.uniqBy

Created: 4 years ago by: Guest

Jump to the latest result

Array.prototype.reduce()

_.uniqBy

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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