Benchmark: Lodash union vs new Set() union

HTML Preparation code:

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

Script Preparation code:

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

Tests:

Lodash union
const c = _.union(a, b)
new Set() union
const setA = new Set(a) const setB = new Set(b) const c = setA.union(setB)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash union
new Set() union

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Lodash union	3862328.5 Ops/sec
new Set() union	2896312.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark you provided focuses on comparing two different approaches for computing the union of two arrays in JavaScript: one using the Lodash library and the other utilizing the native JavaScript `Set` object.

### Benchmark Overview
- **Name**: "Lodash union vs new Set() union"
- **Description**: Not provided, but it aims to compare the performance of two implementations that achieve the same outcome: creating a union of two arrays.
- **Libraries Used**: Lodash, a popular JavaScript utility library that simplifies common tasks such as manipulation and traversal of arrays, objects, and strings.

### Test Cases Explained

1. **Lodash Union Test Case**
    - **Benchmark Definition**: 
      ```javascript
      const c = _.union(a, b);
      ```
      This code uses Lodash’s `_.union` function to find the unique elements from two arrays `a` and `b`. Lodash handles the uniqueness internally and combines the two arrays efficiently.
    - **Advantages**:
        - **Ease of Use**: The syntax is straightforward and does not require deep knowledge of the underlying data structures.
        - **Robustness**: Lodash is well-tested and often optimized for performance in different environments.
    - **Disadvantages**:
        - **Dependency**: It adds the overhead of including the Lodash library into your project which increases bundle size.
        - **Potential Overhead**: For simple operations, there may be slight performance overhead due to abstractions provided by the library.

2. **New Set() Union Test Case**
    - **Benchmark Definition**: 
      ```javascript
      const setA = new Set(a);
      const setB = new Set(b);
      const c = setA.union(setB);
      ```
      This attempts to create a `Set` from both arrays `a` and `b` and calls a non-existent `union()` method. The correct approach would involve merging the sets manually. For example:
      ```javascript
      const c = [...setA, ...setB];
      ```
      Using `Set` is beneficial because it inherently handles uniqueness, ensuring that duplicates are removed.
    - **Advantages**:
        - **No Dependencies**: Native `Sets` are part of the standard JavaScript specification, so no external libraries are required.
        - **Performance**: Generally faster for native operations since it utilizes built-in JavaScript features.
    - **Disadvantages**:
        - **Method Limitation**: As observed, `Set` does not provide a built-in `union` method; users must implement their logic to combine sets, effectively rising complexity.
        - **Manual Handling**: Requires additional steps for union operations compared to using a library function.

### Performance Results
From the benchmark results, we can observe the execution speed of both approaches on Chrome 131.

- **Lodash Union**
  - **Executions Per Second**: 3,862,328.5
- **New Set() Union**
  - **Executions Per Second**: 2,896,312.25

### Conclusions

- **Lodash** shows better performance in this specific benchmark despite its dependency overhead, likely due to its optimized handling of array union operations.
- **Set** requires proper union handling, but is more performant than Lodash in a straightforward comparison without considering the non-existent method invocation error.

### Alternatives
- **Spread Operator and Array Methods**: You can manually compute the union using a combination of the spread operator and methods like `filter()` in conjunction with `includes()`.
- **Other Libraries**: There are alternatives to Lodash, such as Underscore.js, but they typically provide similar functionalities. Proposals like Ramda also offer functional programming techniques but may have different trade-offs regarding performance and usability.

Overall, when performing operations involving unions or array manipulations, it is essential to consider the complexity of the operation, the need for dependencies, maintainability of the code, and testing for performance in your specific environment.

Related benchmarks:

Lodash union vs new Set() union (version: 1)

Comparing performance of: Lodash union vs new Set() union

Created: 3 months ago by: Registered User

Jump to the latest result

Lodash union

new Set() union

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):