Benchmark: get unique entries from two arrays

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js'></script>

Script Preparation code:

var a = "this test is going to be an absolute unit of a thing and I can guarantee a riot".split(' ');
var b = "this test could possibly work out for many of us but will be a riot".split(' ');

Tests:

uniq spread
return _.uniq([...a,...b]);
set spread
return [...new Set([...a,...b])];
uniq _concat
return _.uniq(_.concat(a,b));
set _concat
return [...new Set(_.concat(a,b))];
uniq [concat]
return _.uniq(a.concat(b));
set [concat]
return [...new Set(a.concat(b))];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
uniq spread
set spread
uniq _concat
set _concat
uniq [concat]
set [concat]

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
uniq spread	1266659.1 Ops/sec
set spread	1461362.0 Ops/sec
uniq _concat	1004039.5 Ops/sec
set _concat	1094148.4 Ops/sec
uniq [concat]	1232891.4 Ops/sec
set [concat]	1426509.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The benchmark in question measures the performance of different approaches for finding unique entries between two arrays.

**Library Used: Lodash**

The benchmark uses Lodash, a popular JavaScript library that provides a collection of reusable functions for tasks such as array manipulation, string manipulation, and more. In this case, the `uniq` function from Lodash is used to find unique entries in an array.

**Options Compared**

The benchmark compares five different approaches:

1. **Set Spread**: Using the spread operator (`...`) with a new Set object.
```javascript
return [...new Set([...a,...b])];
```
2. **Concat and Set**: Concatenating the two arrays, then using a new Set object to find unique entries.
```javascript
return [...new Set(_.concat(a,b))];
```
3. **Unique Function from Lodash**: Using the `uniq` function from Lodash to find unique entries in an array.
```javascript
return _.uniq([...a,...b]);
```
4. **Concat and Unique**: Concatenating the two arrays, then passing the resulting array to the `uniq` function from Lodash.
```javascript
return _.uniq(a.concat(b));
```
5. **Unique Function with _concat Method**: Using the `_concat` method of an array (not a common use case) and then passing the resulting array to the `uniq` function from Lodash.
```javascript
return _.uniq(a._concat(b));
```

**Pros and Cons of Each Approach**

1. **Set Spread**:
	* Pros: Efficient, simple implementation, fast execution time.
	* Cons: May not work as expected if one or both arrays are empty, can lead to unexpected results due to the nature of sets.
2. **Concat and Set**:
	* Pros: Works well even when one or both arrays are empty, consistent with traditional array operations.
	* Cons: Less efficient than set spread due to the overhead of concatenating arrays.
3. **Unique Function from Lodash**:
	* Pros: Well-tested implementation, provides a clear and concise result.
	* Cons: May have additional dependencies (Lodash), can be slower due to the overhead of function calls.
4. **Concat and Unique**:
	* Pros: Works well even when one or both arrays are empty, consistent with traditional array operations.
	* Cons: Less efficient than using set spread directly, more complex implementation.
5. **Unique Function with _concat Method**:
	* Pros: None notable.
	* Cons: Not a standard method ( `_concat` is not typically used), can lead to unexpected results due to the non-standard use case.

**Other Considerations**

* The benchmark measures the performance of each approach using a large dataset, providing a good indication of which approach is fastest in practice.
* It's worth noting that while set spread and concat with set are often considered equivalent, they may have different memory and CPU requirements due to the nature of sets versus arrays.

**Alternatives**

For finding unique entries between two arrays, you can also use:

* `Array.from` with a `Set` object:
```javascript
return Array.from(new Set([...a,...b])).sort();
```
* The `reduce` method with an accumulator and a conditional statement to check for uniqueness:
```javascript
var result = [];
for (var i = 0; i < a.length || i < b.length; ++i) {
    var item = i < a.length ? a[i] : undefined;
    if (!result.includes(item)) {
        result.push(item);
    }
}
```
However, these alternatives may have different performance characteristics and are less common than the approaches tested in this benchmark.

Related benchmarks:

get unique entries from two arrays (version: 3)

Comparing performance of: uniq spread vs set spread vs uniq _concat vs set _concat vs uniq [concat] vs set [concat]

Created: one year ago by: Registered User

Jump to the latest result

uniq spread

set spread

uniq _concat

set _concat

uniq [concat]

set [concat]

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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