Benchmark: Lodash union vs Native Javascript

Lodash union vs Native Javascript (version: 0)

This benchmark compares the performance of lodash's `union` function with native JavaScript code for creating an array of unique values from all given arrays. The lodash `union` function creates an array of unique values, in order, from all given arrays. The native JavaScript code uses the `Array.prototype.concat()` method combined with `new Set()` to achieve the same result.

Comparing performance of: lodash.union vs Native JavaScript

Created: 2 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

array1 = [1, 2, 3];
array2 = [3, 4, 5];

Tests:

lodash.union
_.union(array1, array2);
Native JavaScript
[...new Set([...array1, ...array2])];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.union
Native JavaScript

Fastest: N/A

Slowest: N/A

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/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.union	3791506.2 Ops/sec
Native JavaScript	3050572.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

The benchmark compares the performance of two approaches:

1. Lodash's `union` function
2. Native JavaScript code using `Array.prototype.concat()` method combined with `new Set()`

**What is being tested?**

* Performance: The benchmark measures how fast each approach can create an array of unique values from all given arrays.
* Code quality: The benchmark also evaluates the efficiency, readability, and maintainability of each implementation.

**Options compared**

1. **Lodash's `union` function**: This approach uses a JavaScript library (Lodash) to perform the union operation.
	* Pros:
		+ Easy to read and maintain, as it's a well-tested and widely used library.
		+ Provides additional functionality beyond just array manipulation.
	* Cons:
		+ Adds an external dependency (Lodash), which may slow down execution due to overhead of loading the library.
		+ May not be suitable for all use cases, especially those requiring extreme performance or optimization.
2. **Native JavaScript**: This approach uses only built-in JavaScript functions and syntax.
	* Pros:
		+ No external dependencies, resulting in faster execution times.
		+ Suitable for most use cases, as it's a straightforward and efficient way to perform the operation.
	* Cons:
		+ May be less readable or maintainable due to its concise nature.
		+ Requires knowledge of JavaScript internals (e.g., `Array.prototype.concat()` and `new Set()`).

**Considerations**

When choosing between these approaches, consider the following:

* **Performance**: If speed is critical, native JavaScript might be a better choice. However, if readability and maintainability are more important, Lodash's `union` function could be preferred.
* **Code quality**: Both approaches have their strengths and weaknesses in terms of code quality. Native JavaScript requires more effort to write readable and efficient code, while Lodash provides a tested and well-maintained implementation.
* **Use cases**: If the use case involves extreme performance optimization or specialized array manipulation, native JavaScript might be a better fit. Otherwise, Lodash's `union` function could suffice.

**Library (Lodash) and its purpose**

Lodash is a popular JavaScript utility library that provides a comprehensive set of functions for tasks beyond basic array and object manipulation. In this case, the `union` function is used to merge multiple arrays into a single array with unique values.

The library adds value by:

* Providing a tested and well-maintained implementation
* Offering additional functionality beyond basic array manipulation
* Reducing code duplication and improving readability

However, it also introduces an external dependency that may impact execution speed.

**Special JS feature or syntax**

There is no special JavaScript feature or syntax used in this benchmark. Both approaches utilize standard JavaScript functions and syntax (e.g., `Array.prototype.concat()` and `new Set()`).

**Other alternatives**

If you're looking for alternative implementations, consider:

* Using a different library or implementation for array union (e.g., `p-union` or `lodash.merge`) that might offer improved performance or features.
* Implementing the union operation from scratch using custom algorithms and data structures (e.g., hash tables or bitmasks).
* Utilizing specialized libraries or frameworks designed specifically for array manipulation or optimization (e.g., Apache Arrow or Numba).

Related benchmarks: