Benchmark: Test Lodash Union vs Set

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:

Lodash Union and join
var c = _.union(a, b).join(' ')
Set and join
new Set([...a,...b]).values().toArray().join(' ')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash Union and join
Set and join

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 128 on Android

View result in a separate tab

Test name	Executions per second
Lodash Union and join	320599.3 Ops/sec
Set and join	296564.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark is designed to compare two approaches: using Lodash's `union` function with the `join` method, and using the built-in `Set` data structure in conjunction with `values`, `toArray`, and `join`.

**What are being tested?**

In the first test case (`Lodash Union and join`), the benchmark tests how efficient it is to perform a union operation on two arrays (`a` and `b`) using Lodash's `union` function, followed by joining the resulting array into a string using the `join` method.

In the second test case (`Set and join`), the benchmark tests how efficient it is to create a set from the concatenation of two arrays (`a` and `b`) using the spread operator (`...`), converting the set to an array with `values`, `toArray`, and finally joining the resulting array into a string.

**Options compared:**

The two approaches being compared are:

1. **Lodash's `union` function**: A library function that performs a union operation on two arrays, returning a new array containing all unique elements from both input arrays.
2. **Built-in `Set` data structure**: A built-in JavaScript data structure that automatically eliminates duplicates when elements are added.

**Pros and Cons of each approach:**

**Lodash's `union` function:**

Pros:

* Easy to use and implement
* Well-tested and optimized by the Lodash team

Cons:

* Requires including an external library (Lodash) in your code
* May have overhead due to the need to load an additional JavaScript file or module

**Built-in `Set` data structure:**

Pros:

* No external dependencies required
* Efficient and lightweight, with low overhead

Cons:

* Requires understanding of the spread operator (`...`) and set creation syntax
* May require more manual error handling when dealing with duplicate elements or incorrect usage

**Other considerations:**

When choosing between these two approaches, consider the following factors:

* Performance: The built-in `Set` data structure is generally faster for small to medium-sized datasets. However, for very large datasets or those requiring complex set operations, Lodash's `union` function might be more efficient.
* Code complexity and readability: Using a library like Lodash can add some abstraction overhead, while relying on the built-in `Set` data structure requires a better understanding of its internal workings.

**Library usage (Lodash):**

In this benchmark, Lodash is used to perform a union operation on two arrays. The specific function called is `_union(a, b)`, which returns a new array containing all unique elements from both input arrays.

**Special JavaScript features or syntax:**

This benchmark does not use any special JavaScript features or syntax that are not widely supported across different browsers and environments. However, it's worth noting that the `Spread Operator` (`...`) is a relatively recent feature introduced in ECMAScript 2015 (ES6). While most modern browsers support it, older versions might not be compatible.

**Alternatives:**

If you're looking for alternative approaches to union operations or set creation, consider using other libraries like:

* `Array.prototype.filter()` and `Set` data structure
* `Array.prototype.reduce()` with a custom merge function
* `lodash-es` (a subset of Lodash optimized for ES6 compatibility)
* Other specialized libraries like `underscore` or `ramda`

Related benchmarks:

Test Lodash Union vs Set (version: 0)

asdf

Comparing performance of: Lodash Union and join vs Set and join

Created: one year ago by: Guest

Jump to the latest result

Lodash Union and join

Set and join

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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