Benchmark: Lodash _.union vs native Set() and Set to Array

HTML Preparation code:

<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js"></script>

Script Preparation code:

var a = [1, 2, 3, 4, 5]
var b = [3, 4, 5, 6, 7]

Tests:

_.union
var c = _.union(a, b)
Set()
var c = new Set(a, b)
Set() convert back to array
var c = [...new Set(a, b)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.union
Set()
Set() convert back to array

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Linux

View result in a separate tab

Test name	Executions per second
_.union	1410148.8 Ops/sec
Set()	1886672.9 Ops/sec
Set() convert back to array	1512137.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Overview**

The benchmark, hosted on MeasureThat.net, compares three approaches to union two arrays in JavaScript:

1. Using the `lodash` library's `_union` function (Lodash _.union)
2. Creating a new Set using the native `Set()` constructor
3. Converting the result of the native Set creation back to an array

**Library and Purpose**

The `lodash` library is a popular JavaScript utility library that provides various functional programming helpers, including data manipulation functions like `_union`. In this benchmark, it's used to implement the `_union` function.

**Test Cases and Approaches**

Here are the individual test cases with their descriptions:

1. **Lodash _.union**: This test case measures the performance of the `lodash` library's `_union` function. It takes two arrays as input (`a` and `b`) and returns a new array containing all unique elements from both arrays.
2. **Set()**: This test case creates a new Set using the native `Set()` constructor, passing `a` and `b` as arguments. Sets in JavaScript are unordered collections of unique values, making them ideal for this use case. The test case measures the performance of creating a new Set from two arrays.
3. **Set() convert back to array**: This test case creates a new Set using the native `Set()` constructor, passing `a` and `b` as arguments, just like in the previous test case. However, instead of measuring the performance of the Set creation directly, it measures the performance of converting the resulting Set back to an array.

**Comparison and Pros/Cons**

Here's a comparison of the three approaches:

* **Lodash _.union**: This approach uses a pre-existing library function, which might introduce some overhead due to the function call and potential caching mechanisms. However, `lodash` is a widely used and well-maintained library, so it's likely that its implementation is optimized for performance.
	+ Pros: Easy to use, well-tested, and optimized by the library authors.
	+ Cons: Introduces additional overhead due to the function call and potential caching.
* **Set()**: This approach creates a new Set directly from the arrays, which can be more efficient since Sets are implemented as hash tables. However, it requires manual handling of duplicates and conversion back to an array if needed.
	+ Pros: Can be more efficient for large datasets, as Sets can handle duplicates efficiently.
	+ Cons: Requires manual handling of duplicates and conversion back to an array.
* **Set() convert back to array**: This approach is similar to the native Set creation, but with the added overhead of converting the result back to an array. This test case measures the performance of this additional step.
	+ Pros: Similar efficiency benefits as creating a new Set directly from the arrays.
	+ Cons: Introduces additional overhead due to the conversion step.

**Special Considerations**

This benchmark does not specifically target any special JavaScript features or syntax, so it should be relevant to most software engineers familiar with JavaScript basics.

**Alternatives**

Other approaches to union two arrays in JavaScript include:

* Using `concat()` and checking for duplicates using `indexOf()`: This approach is simple but might be less efficient due to the overhead of function calls and potential duplicate checks.
* Using a custom implementation without relying on any library functions: This approach would require implementing the union logic manually, which can be more error-prone but allows for fine-grained control over performance.

Keep in mind that this benchmark is specific to JavaScript and its Set data structure. The results may not directly translate to other programming languages or data structures.

Related benchmarks:

Lodash _.union vs native Set() and Set to Array (version: 0)

Comparing performance of: _.union vs Set() vs Set() convert back to array

Created: 2 years ago by: Guest

Jump to the latest result

_.union

Set()

Set() convert back to array

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