Benchmark: Corrected Lodash _.union vs native Set()

Corrected Lodash _.union vs native Set() (version: 0)

The original does not correctly create the Set object from two arrays. Added alternate tests for using the Array functions, just in case they differ from spreading.

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

Created: 2 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/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.concat(b))
Set() using array spread
var c = new Set([...a, ...b])
Set() convert back to array
var c = new Set(a.concat(b)) var d = Array.from(c)
Set() convert back to array using array spread
var c = new Set([...a, ...b]) var d = [...c]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

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.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The benchmark tests the performance of creating a set from two arrays using different approaches:

1. Using the `_.union` function from the Lodash library (version 4.17.5).
2. Creating a native Set object using the `Set()` constructor and the `concat()` method.
3. Creating a native Set object using the `Set()` constructor and the array spread syntax (`[...a, ...b]`).
4. Converting the Set object back to an array using `Array.from(c)` or `[...c]`.
5. Similar to test case 2, but converting the Set object back to an array using `Array.from(c)`.

**What options are compared?**

The benchmark compares the performance of five different approaches:

1. Using Lodash's `_.union` function.
2. Creating a native Set object using `Set()` and `concat()`.
3. Creating a native Set object using `Set()` and array spread syntax (`[...a, ...b]`).
4. Converting the Set object back to an array using `Array.from(c)`.
5. Similar to test case 2, but converting the Set object back to an array using `[...c]`.

**Pros and cons of each approach:**

1. **Lodash's _.union**: Pros:
	* Easy to use.
	* Well-tested library.
	* May have additional features or optimizations not present in native implementations.
	Cons:
		+ Additional overhead due to library loading.
		+ May not be as performant as native implementations.
2. **Native Set() with concat()**: Pros:
	* Native implementation, so no extra overhead from libraries.
	* Simple and easy to use.
	Cons:
		+ Less efficient than using array spread syntax.
3. **Native Set() with array spread**: Pros:
	* More efficient than using `concat()` method.
	* Easy to read and write.
	Cons:
		+ May not be as widely supported in older browsers or environments.
4. **Converting Set back to array with Array.from(c)**: Pros:
	* Convenient way to get an array representation of the set.
	* Works well when you need an array.
	Cons:
		+ Additional overhead due to conversion.
5. **Converting Set back to array with [...c]**: Similar pros and cons as test case 4.

**Other considerations:**

1. **Performance differences**: The benchmark results show significant performance differences between the five approaches, with Lodash's `_.union` being the fastest (in this specific scenario).
2. **Browser support**: The use of array spread syntax (`[...a, ...b]`) may not be supported in older browsers or environments.
3. **Library loading**: If you choose to use a library like Lodash, consider the overhead of loading and initializing it.

**Other alternatives:**

If you need to create a set from two arrays, consider using:

1. `Set().add()` method with each element individually (not shown in this benchmark).
2. Using a library other than Lodash, such as Ramda or Immutable.js.
3. Creating an array with unique elements using `[...new Set(a.concat(b))].`

Keep in mind that the best approach depends on your specific use case and requirements.

If you have any further questions or need more clarification, feel free to ask!

Related benchmarks: