Benchmark: Lodash "uniqWith" "uniqBy" "unionWith" "unionBy"

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.21/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), _.isEqual);
uniqBy
const unionUsers2 = _.uniqBy(newUsers.concat(users), 'name');
UnionWith
const unionUsers3 = _.unionWith(newUsers, users, _.isEqual);
unionBy
const unionUsers4 = _.unionBy(newUsers, users, 'name');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
uniqWith
uniqBy
UnionWith
unionBy

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript functions like Lodash's `uniqWith`, `uniqBy`, `unionWith`, and `unionBy` is crucial for understanding their efficiency in different scenarios.

**Benchmarked Functions:**

1.  **`uniqWith`**: Removes duplicate elements from an array, using a provided function to determine whether two elements are equal.
2.  **`uniqBy`**: Similar to `uniqWith`, but uses the value at specified keys to determine uniqueness instead of a custom comparison function.
3.  **`unionWith`**: Combines two arrays into one, removing duplicates based on an equality function.
4.  **`unionBy`**: Similar to `unionWith`, but combines arrays using values from a specific key.

**Comparison Options:**

These four functions are compared in the benchmark. Here's what each option does:

*   **`uniqWith` and `unionWith`**: These functions use an equality function (`.isEqual` from Lodash) to compare elements and determine uniqueness.
    *   **Pros:** Fast execution, especially when using a well-optimized equality function like `.isEqual`.
    *   **Cons:** May not perform as well if the comparison function is complex or has a high overhead, such as with recursive functions or those involving multiple operations.
*   **`uniqBy` and `unionBy`**: These functions use the value at specified keys (`'name'`) to determine uniqueness.
    *   **Pros:** Faster execution when comparing based on a simple key like `'name'`.
    *   **Cons:** May perform less well if the comparison function is complex or has a high overhead.

**Lodash Library:**

The `_.uniqWith`, `_.uniqBy`, `_.unionWith`, and `_.unionBy` functions are all part of the Lodash library. The library provides various utility functions for functional programming tasks, including array manipulation, object manipulation, and more.

*   **`.isEqual()`**: A strict equality function that checks if two values have the same value, type, and location in memory.
*   **`.isEqualWith()`**: Similar to `.isEqual()`, but allows for a custom comparison function.

**Other Considerations:**

1.  *   Cache locality:** In some cases, the order of elements or the order in which comparisons are performed can affect performance (cache locality). This might impact the results of these benchmarks.
2.  *   Parallel execution:** The benchmark may not accurately represent parallel execution scenarios where multiple processors or threads execute different parts of the code concurrently.

**Alternatives:**

If you need alternative implementations for these functions, here's how you could write them in JavaScript:

1.  **`uniqWith`**: You can implement `uniqWith` without Lodash's `.isEqual()` by comparing elements based on a custom comparison function:
    ```javascript
function isUnique(a, b) {
  // Custom equality check here.
}

const unionUsers = (a, b) => [...new Set(a.map((x) => x.toString() + ',' + isUnique(x, b)))];
```

2.  **`uniqBy`**: Implement `uniqBy` by comparing elements based on the value at a specified key:
    ```javascript
function getUniqueKey(obj) {
  return obj.name;
}

const unionUsers = (a, b) => [...new Set(a.map((x) => x.toString() + ',' + getUniqueKey(x)))];
```

3.  **`unionWith`**: Implement `unionWith` using a custom comparison function:
    ```javascript
function isUnique(a, b) {
  // Custom equality check here.
}

const unionUsers = (a, b) => [...new Set(a.map((x) => x.toString() + ',' + isUnique(x, b)))];
```

4.  **`unionBy`**: Implement `unionBy` by comparing elements based on the value at a specified key:
    ```javascript
function getUniqueKey(obj) {
  return obj.name;
}

const unionUsers = (a, b) => [...new Set(a.map((x) => x.toString() + ',' + getUniqueKey(x)))];
```

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

Browser/OS: Chrome 102 on Windows

View result in a separate tab

Test name	Executions per second
uniqWith	0.8 Ops/sec
uniqBy	4624.6 Ops/sec
UnionWith	0.8 Ops/sec
unionBy	3942.8 Ops/sec

Related benchmarks:

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

Comparing performance of: uniqWith vs uniqBy vs UnionWith vs unionBy

Created: 2 years ago by: Guest

Jump to the latest result

uniqWith

uniqBy

UnionWith

unionBy

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