Benchmark: Set.difference vs Filter

Script Preparation code:

var array1 = Array.from({length: 40}, () => Math.floor(Math.random() * 140));
var array2 = Array.from({length: 20}, () => Math.floor(Math.random() * 140));
var setFromArray1 = new Set(array1)
var setFromArray2 = new Set(array2)

Tests:

Set.difference
const setDiff = setFromArray1.difference(setFromArray2)
Array.filter
const arrayFilter = array1.filter(value => array2.indexOf(value))
Array.filter with Set.has
const arrayFilterWithSetHas = array1.filter(value => setFromArray2.has(value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set.difference
Array.filter
Array.filter with Set.has

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Set.difference	0.0 Ops/sec
Array.filter	957967.7 Ops/sec
Array.filter with Set.has	2532799.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark being tested is comparing the performance of three different approaches to find the difference between two sets of values represented by arrays in JavaScript. Below is a detailed explanation of the options being compared, their pros and cons, and the libraries used, if any.

### Benchmark Definitions

1. **Set.difference**: 
   ```javascript
   const setDiff = setFromArray1.difference(setFromArray2);
   ```
   - **Description**: This uses a hypothetical method `.difference` on the `Set` object that is meant to calculate the difference between `setFromArray1` and `setFromArray2`.
   - **Performance Result**: This benchmark case returned an execution speed of `0.0`, indicating that the method was either not implemented or incorrectly called since the native `Set` object in JavaScript does not have a `difference` method natively.
   - **Pros/Cons**: 
     - **Pros**: If correctly implemented, this method would provide clear semantics for finding the difference between two sets and potentially be very efficient.
     - **Cons**: Lack of native support means that either a custom implementation has to be made or an external library must be included, leading to potential performance issues if managed improperly.

2. **Array.filter**:
   ```javascript
   const arrayFilter = array1.filter(value => array2.indexOf(value));
   ```
   - **Description**: This uses the `filter` method on the first array (`array1`) to return a new array containing only those elements that exist in `array2` (using `indexOf`).
   - **Performance Result**: This benchmark returned `957967.6875` executions per second, which demonstrates that while it works, this approach could be inefficient for larger datasets.
   - **Pros/Cons**:
     - **Pros**: Simple and easy to understand; leverages built-in array methods.
     - **Cons**: The use of `indexOf` results in a time complexity of O(n*m), worsening performance with larger arrays, as it checks each element of `array1` against all elements in `array2`.

3. **Array.filter with Set.has**:
   ```javascript
   const arrayFilterWithSetHas = array1.filter(value => setFromArray2.has(value));
   ```
   - **Description**: Similar to the previous filter method, but here it scans `array1` and checks if each value exists in `setFromArray2` using the `.has` method of the `Set`. This provides a more efficient check due to the underlying data structure's O(1) average time complexity for lookups.
   - **Performance Result**: This method demonstrated the best performance, with `2532799.75` executions per second, showing it's significantly more efficient than the previous two approaches.
   - **Pros/Cons**:
     - **Pros**: Using a `Set` for lookups dramatically increases the efficiency of the operation, making it the optimal choice for this use case.
     - **Cons**: Requires an additional data structure, which adds some overhead in memory usage.

### Conclusion

In summary, the benchmark assesses three methods for computing the difference/matching values between two arrays. The first method attempts to leverage a non-existent `Set.difference` method, which resulted in an ineffective benchmark. The second method using `Array.filter` with `indexOf` is straightforward but inefficient for larger datasets due to its O(n*m) time complexity. The best performance came from using `Array.filter` along with `Set.has`, which provides a clear performance advantage.

Alternative approaches might include:
- Using external libraries like Lodash or Underscore.js, which may offer optimized and well-tested methods for computing array differences.
- Implementing a custom function to calculate the array difference that directly loops through items and uses a `Set` for lookups, balancing performance and clarity.

These alternatives would depend on project requirements, including complexity, readability, and performance optimizations.

Related benchmarks:

Set.difference vs Filter (version: 2)

Comparing performance of: Set.difference vs Array.filter vs Array.filter with Set.has

Created: one month ago by: Registered User

Jump to the latest result

Set.difference

Array.filter

Array.filter with Set.has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):