Benchmark: Lodash "unionWith" "unionBy" 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:

unionWith1
const unionUsers1 = _.unionWith(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
unionWith1
unionBy
unionWith2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36 Edg/100.0.1185.50

Browser/OS: Chrome 100 on Windows

View result in a separate tab

Test name	Executions per second
unionWith1	65.8 Ops/sec
unionBy	4024.9 Ops/sec
unionWith2	54.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Benchmark Definition**

The benchmark is created to compare the performance of two different functions from the Lodash library: `unionWith` and `unionBy`. The tests are designed to measure which function is faster when performing a union operation on two arrays (`users` and `newUsers`) based on a specific key (in this case, the `name` property).

**Test Cases**

There are three test cases:

1. `unionWith1`: This test uses the `unionWith` function from Lodash, which takes an additional callback function as its third argument. The callback function compares two objects and returns true if they have the same value for the specified key (`name`). If both objects have the same value, they are merged; otherwise, the first object is added to the result.
2. `unionBy`: This test uses the `unionBy` function from Lodash, which takes a callback function as its second argument. The callback function compares two values and returns true if they are equal.

**Options Compared**

The benchmark is comparing the performance of two different approaches:

* `unionWith`: Uses an additional callback function to compare objects based on the specified key.
* `unionBy`: Uses a simple comparison function to compare values.

**Pros and Cons of Each Approach**

1. **`unionWith`**:
	* Pros: Can handle complex object merging scenarios, provides more control over the merge process.
	* Cons: Requires an additional callback function, which can introduce overhead.
2. **`unionBy`**:
	* Pros: Simplifies the comparison process, reduces code complexity.
	* Cons: May not be suitable for complex object merging scenarios, as it relies on a simple equality check.

**Library and Its Purpose**

The Lodash library provides several utility functions, including `unionWith` and `unionBy`, to simplify common programming tasks. These functions are designed to work with arrays of objects and provide a way to merge or combine them based on specific criteria.

* `_.unionWith`: Used for merging two arrays of objects into a new array, where each object is merged based on the specified key.
* `_.unionBy`: Used for merging two arrays of values into a new array, where each value is compared using the provided callback function.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code uses standard ES6 syntax and relies on Lodash library functions to perform the union operations.

**Other Alternatives**

If you're interested in exploring alternative libraries or implementations for union operations, here are a few options:

* **Array.prototype.reduce()**: You can use the `reduce()` method of an array to merge two arrays of objects based on a specified key.
* **Manual iteration**: You can iterate over each element of both arrays and manually check for equality or merging using a custom function.
* **Other libraries**: There are other libraries, such as Ramda, that provide similar functions for union operations.

Related benchmarks:

Lodash "unionWith" "unionBy" 4 (version: 1)

Comparing performance of: unionWith1 vs unionBy vs unionWith2

Created: 4 years ago by: Registered User

Jump to the latest result

unionWith1

unionBy

unionWith2

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