Benchmark: Lodash _.union vs native Set() vs Concat & filter

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]
Array.prototype.cfunion = function (array) {
  var conc = this.concat(array);
  return conc.filter((i,p)=>{
    return conc.indexOf(i) == p
  });
};

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) var d = Array.from(c)
Concat & Filter
var c = a.cfunion(b)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Overview**

The test compares three approaches to create a union of two arrays:

1. `Lodash _.union`
2. `native Set()` (using the built-in `Set` constructor)
3. `Concat & Filter`

These three approaches are compared because they represent different ways to solve the same problem: merging two arrays into one without duplicates.

**Options Compared**

* `_.union`: Uses Lodash's utility function to merge two arrays.
* `native Set()`: Utilizes JavaScript's built-in `Set` constructor, which is a collection of unique values.
* `Concat & Filter`: Merges two arrays using the `concat()` method and then filters out duplicates using an arrow function.

**Pros and Cons**

1. **_.union (Lodash)**:
	* Pros: Concise and readable code, Lodash's utility functions are well-maintained and widely used.
	* Cons: Requires an additional library dependency (Lodash).
2. **native Set()**:
	* Pros: Fast and efficient, as `Set` is implemented in native JavaScript.
	* Cons: May require some manual effort to convert the resulting set back into an array.
3. **Concat & Filter**:
	* Pros: No additional library dependencies required, can be easily optimized for performance.
	* Cons: More verbose code compared to Lodash's `_.union` and may not be as readable.

**Library and Syntax**

The benchmark uses the Lodash library, which is a popular utility library for JavaScript. It provides a range of functions for tasks like array manipulation, object creation, and more.

**Special JS Features or Syntax**

There are no special JS features or syntax used in this benchmark that would require prior knowledge of specific language features. However, the use of `Set` as a data structure is a common pattern in JavaScript, so familiarity with basic Set operations may be helpful.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are some additional options:

* Using `Array.from()` to convert a `Set` back into an array: This approach is similar to the `Concat & Filter` method but uses `Array.from()` instead.
* Using a custom implementation of the union operation using bitwise operations or other algorithms.
* Using a different library or framework that provides optimized implementations for array merging and filtering.

These alternatives might offer better performance or readability, depending on your specific use case and requirements.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 OPR/113.0.0.0 (Edition developer)

Browser/OS: Opera 113 on Windows

View result in a separate tab

Test name	Executions per second
_.union	2923083.2 Ops/sec
Set()	4594414.5 Ops/sec
Set() convert back to array	3274751.5 Ops/sec
Concat & Filter	3835623.0 Ops/sec

Related benchmarks:

Lodash _.union vs native Set() vs Concat & filter (version: 0)

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

Created: 5 years ago by: Guest

Jump to the latest result

_.union

Set()

Set() convert back to array

Concat & Filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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