Benchmark: Array immutable union: underscore union vs vs uniq

HTML Preparation code:


<script src='https://cdn.jsdelivr.net/npm/underscore@1.12.1/underscore-min.js'></script>

Tests:

underscore union
var a = [ 'a', 'b', 'c' ]; var b = [ 'b', 'd', 'a', 'e', 'f' ]; var c = _.union(a, b);
object.assign
var a = [ 'a', 'b', 'c' ]; var b = [ 'b', 'd', 'a', 'e', 'f' ]; var c = Object.assign([], a, b);
underscore uniq spread
var a = [ 'a', 'b', 'c' ]; var b = [ 'b', 'd', 'a', 'e', 'f' ]; var c = _.uniq([...a, ...b]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
underscore union
object.assign
underscore uniq spread

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 27 days ago):

LLMs can make mistakes. Check important info.

This benchmark compares three different methods for finding the unique elements in two arrays:

**1. `underscore union`**:

* **Method**: Uses the `_.union()` function from the Underscore.js library. This library is designed to provide utility functions for working with JavaScript collections, including arrays.
* **Pros**: Concise and efficient, leverages a dedicated library optimized for this task.
* **Cons**:  Relies on an external library which might add overhead if not already included in your project.

**2. `object.assign`**:

* **Method**: Creates a new array using `Object.assign()` and combines the elements of both input arrays.
* **Pros**: Standard JavaScript, no external libraries required.
* **Cons**: Less efficient than specialized methods like `_.union()`.  Can be harder to read and understand for its specific purpose.

**3. `underscore uniq spread`**:

* **Method**: Uses the `_.uniq()` function from Underscore.js combined with the spread operator (`...`) to create a new array containing unique elements.
* **Pros**: Utilizes a specialized library function, potentially efficient.
* **Cons**: Again, relies on an external library.

**Other Alternatives:**

* **Set Intersection**:  JavaScript's `Set` object can be used to efficiently find the union of arrays. Convert each array into a Set, then use the `intersection()` method or logic like: 
    ```javascript
    const setA = new Set(arrayA);
    const setB = new Set(arrayB);

const uniqueElements = [...new Set([...setA, ...setB])];
    ```
* **`filter` and `indexOf`**: You can combine the `filter` method to remove duplicates and the `indexOf` method for checking existence within an array. This is less efficient than the alternatives but demonstrates a purely native JavaScript approach.

**Important Considerations:**

* **Performance**: The benchmarks show that `underscore uniq spread` and `underscore union` are significantly faster than `object.assign`. For large datasets, performance differences become more noticeable.
* **Readability**: While  `object.assign` is straightforward, using library functions like `_.union()` can make your code more concise and readable, especially for common tasks like array manipulation.

Let me know if you have any other questions!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.88 Safari/537.36

Browser/OS: Chrome 100 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
underscore union	3007483.0 Ops/sec
object.assign	530632.6 Ops/sec
underscore uniq spread	3511533.5 Ops/sec

Related benchmarks:

Array immutable union: underscore union vs vs uniq (version: 0)

Comparing performance of: underscore union vs object.assign vs underscore uniq spread

Created: 3 years ago by: Guest

Jump to the latest result

underscore union

object.assign

underscore uniq spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 27 days ago):