Benchmark: Lodash "uniqWith" "unionBy" "uniqBy" 27062023

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js'></script>

Script Preparation code:

var users = [
  { 'name': 'barney',  'age': 36 },
  { 'name': 'pebbles', 'age': 5 }
];

var newUsers = [
  { 'name': 'fred',    'age': 40 },
  { 'name': 'barney',  'age': 36 },
  { 'name': 'pebbles', 'age': 2 }
];

for(let i = 0; i < 2000; i++) {
  var newUser = { 'name': 'user_' + i, 'age': Math.floor(Math.random() * i) };
  newUsers.push(newUser);
}

Tests:

uniqWith
const unionUsers1 = _.uniqWith(newUsers.concat(users), (userA, userB) => userA.name === userB.name);
unionBy
const unionUsers2 = _.unionBy(newUsers, users, 'name');
uniqBy
const unionUsers1 = _.uniqBy(newUsers.concat(users), 'name');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
uniqWith
unionBy
uniqBy

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents two benchmark definitions for Lodash, a popular JavaScript utility library. The first definition is a single test case that measures the performance of three different functions: `uniqWith`, `unionBy`, and `uniqBy`. These functions are used to perform set operations on arrays.

**What is tested?**

In this benchmark, we have three individual test cases:

1. **`uniqWith`**: This function takes two arrays as input and returns a new array containing only the elements that pass a provided comparison function (in this case, `userA.name === userB.name`). The goal is to measure the performance of this function when given two arrays with overlapping elements.
2. **`unionBy`**: This function merges two arrays based on a common key (in this case, `'name'`). It returns a new array containing all unique elements from both input arrays.
3. **`uniqBy`**: Similar to `unionBy`, but it returns an array of unique elements only.

**Options compared**

In each test case, we have two options:

* **`_.uniqWith`** vs. **
* **`.unionBy`** vs. **
* **`.uniqBy`**

These options differ in how they perform set operations on the input arrays:

1. `_.uniqWith`: This function uses a custom comparison function to determine whether elements should be included in the result.
2. `.unionBy`: This function merges two arrays based on a common key and returns a new array containing all unique elements.
3. `.uniqBy`: Similar to `.unionBy`, but it only includes unique elements.

**Pros and Cons**

Here are some pros and cons of each approach:

1. `_.uniqWith`:
	* Pros: Can be flexible in terms of the comparison function used, allowing for custom logic.
	* Cons: May have a higher overhead due to the need for a custom function.
2. `.unionBy`:
	* Pros: Fast and efficient, especially when merging large arrays.
	* Cons: Requires a common key to be specified, which may not always be available or meaningful.
3. `.uniqBy`:
	+ Pros: Similar benefits to `.unionBy`, with the added benefit of only including unique elements.
	+ Cons: May have performance issues if the input array is very large.

**Library and syntax**

In this benchmark, we're using Lodash (version 4.17.10) as the utility library. No special JavaScript features or syntax are used in this benchmark.

**Other alternatives**

If you need to perform set operations on arrays, other alternatives include:

1. **`Array.prototype.reduce()`**: A built-in method that can be used to merge or filter arrays based on a custom function.
2. **`Set` objects**: Native JavaScript data structures that can be used to store and manipulate unique elements.

However, for large-scale performance-critical applications, Lodash's optimized implementations of these functions are likely to remain the best choices.

I hope this explanation helps you understand what's going on in this benchmark!

Related benchmarks:

Lodash "uniqWith" "unionBy" "uniqBy" 27062023 (version: 0)

Comparing performance of: uniqWith vs unionBy vs uniqBy

Created: 2 years ago by: Guest

Jump to the latest result

uniqWith

unionBy

uniqBy

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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