Benchmark: Lodash "unionWith" "unionBy" "uniqWith"4

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, users, (newUser, user) => newUser.name === user.name);
unionBy
const unionUsers2 = _.unionBy(newUsers, users, (user) => user.name);
unionWith2
const unionUsers1 = _.unionWith(newUsers, users, (newUser, user) => newUser.name === user.name);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
uniqWith
unionBy
unionWith2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition and Purpose**

The provided JSON represents a benchmark test case that compares three different ways to union (merge) two arrays of objects in Lodash, a popular JavaScript utility library. The test case is designed to measure the performance of these operations.

**Options Compared**

There are three options compared:

1. `uniqWith`
2. `unionBy`

Both functions aim to merge two arrays (`newUsers` and `users`) into a single array while preserving unique values. However, they achieve this in different ways.

**uniqWith**

`uniqWith` uses a custom comparison function to determine whether two objects are equal or not. In this case, the comparison function is `(newUser, user) => newUser.name === user.name`, which checks if the `name` property of both objects is equal.

Pros:

* Can be used when comparing complex objects with multiple properties.
* Allows for custom comparison logic.

Cons:

* May have performance overhead due to the use of a custom comparison function.
* Requires careful consideration of the comparison function's impact on performance.

**unionBy**

`unionBy` uses the `name` property as a key to merge the arrays. It simply checks if the `name` property of both objects is equal, which is faster than using a custom comparison function.

Pros:

* Faster execution compared to `uniqWith`.
* Simpler and more intuitive code.

Cons:

* Assumes that the `name` property is unique among objects in both arrays.
* May not work correctly if there are duplicate values in either array.

**unionWith2**

This option seems to be a typo or an error, as it is identical to `unionBy`. I'll assume it's meant to be `unionWith`.

**Other Considerations**

When comparing these two functions, it's essential to consider the trade-offs between performance and simplicity. While `unionBy` may be faster, it assumes that the `name` property is unique, which might not always be the case. On the other hand, `uniqWith` provides more flexibility but may incur a performance overhead.

**Library and Purpose**

Lodash is a popular JavaScript utility library that provides various functions for tasks such as:

* Array manipulation (e.g., `unionBy`, `uniqWith`)
* Object manipulation (e.g., `pick`, `omit`)
* Function manipulation (e.g., `curry`, `bind`)
* String manipulation (e.g., `escape`, `unescape`)

Lodash is designed to provide a comprehensive set of utility functions that can be used in various JavaScript applications.

**Special JS Feature or Syntax**

There doesn't appear to be any special JavaScript feature or syntax being used in this benchmark. The code relies solely on standard JavaScript syntax and Lodash functions.

**Alternatives**

If you're looking for alternative libraries or implementations, here are a few options:

* `Array.prototype.reduce()`: This method can be used to merge arrays, but it may not be as efficient as the Lodash implementation.
* `Array.prototype.concat()`: This method can also be used to merge arrays, but it may have performance implications if dealing with large datasets.

However, for most use cases, Lodash's implementations of `unionBy` and `uniqWith` are likely to be the best choice due to their performance and flexibility.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0

Browser/OS: Firefox 89 on Windows

View result in a separate tab

Test name	Executions per second
uniqWith	2593.3 Ops/sec
unionBy	615.4 Ops/sec
unionWith2	15.3 Ops/sec

Related benchmarks:

Lodash "unionWith" "unionBy" "uniqWith"4 (version: 0)

Comparing performance of: uniqWith vs unionBy vs unionWith2

Created: 3 years ago by: Guest

Jump to the latest result

uniqWith

unionBy

unionWith2

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