Benchmark: Set from array vs array Filter unique

Script Preparation code:

var array = Array.from({length: 40}, () => Math.floor(Math.random() * 140));

Tests:

Set from array
const a = new Set(array)
Filter
const filterUnique = (value, index, array) => array.indexOf(value) === index; const b = array.filter(filterUnique)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set from array
Filter

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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's being tested.

**Benchmark Overview**

The test case compares two approaches for creating a unique array: using a `Set` object or filtering out duplicates using the `Array.prototype.filter()` method with a custom callback function. This comparison aims to determine which approach is faster in JavaScript.

**Test Case 1: Set from Array**

This test creates a new `Set` object from an array of random integers. The `Set` data structure automatically removes duplicate values, making it efficient for this scenario.

```javascript
const a = new Set(array);
```

In this case, the pros are:

*   **Efficient**: Creating a `Set` is relatively fast and efficient since it uses a hash table to store unique elements.
*   **Simple implementation**: The code is straightforward and doesn't require complex logic or additional libraries.

However, there are some cons to consider:

*   **Memory usage**: Since the `Set` object stores references to its elements (in this case, the array values), it may consume more memory compared to other approaches.
*   **Limited functionality**: The `Set` data structure is designed for storing unique values and doesn't provide additional features like sorting or iterating over its elements in a specific order.

**Test Case 2: Filter**

This test uses an alternative approach by defining a custom callback function `filterUnique` that checks if the value's index in the original array matches its presence in the array using `Array.prototype.indexOf()`. Then, it filters out duplicates from the array using this callback function.

```javascript
const filterUnique = (value, index, array) => array.indexOf(value) === index;
const b = array.filter(filterUnique);
```

In this case:

*   **Custom logic**: The code requires defining a custom callback function, which can be more verbose and error-prone compared to using built-in data structures.
*   **Performance overhead**: Creating and executing the custom callback function might introduce additional overhead due to its complexity.

However, there are also some advantages:

*   **Flexibility**: This approach provides full control over filtering logic, making it suitable for more complex scenarios where multiple conditions need to be applied.
*   **Faster iteration**: Since `Array.prototype.filter()` is a built-in method optimized for performance, the filter operation itself might be faster than using a `Set`.

**Other Considerations**

When comparing these two approaches, consider the following:

*   **Memory efficiency**: If memory usage is critical, using an array with unique elements (like a `Set`) might be more efficient.
*   **Code readability and maintainability**: For larger datasets or complex filtering logic, defining a custom callback function can make code easier to understand and modify.

**Alternatives**

In addition to these two approaches:

*   Using a library like Lodash (`_.uniq()`, for example) that provides optimized methods for removing duplicates from arrays.
*   Utilizing `Array.prototype.reduce()` or `Array.prototype.every()` with custom callback functions for filtering and reducing operations.
*   Implementing your own sorting algorithm (e.g., radix sort, counting sort) if the array needs to be sorted in addition to being filtered.

For a wide range of software engineers, it's essential to understand these concepts to make informed decisions when implementing data structures or algorithms in JavaScript.

Related benchmarks:

Set from array vs array Filter unique (version: 0)

Comparing performance of: Set from array vs Filter

Created: 2 years ago by: Registered User

Jump to the latest result

Set from array

Filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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