Benchmark: Dedup Array of Objects (4 strats)

Script Preparation code:

const ids = Array.from({
    length: 1000
}, () => Math.random().toString(16).slice(2));
const array = [...ids.map((id) => ([{
                id: id,
                content: "foo"
            }, {
                id: id,
                content: "bar"
            }, {
                id: id,
                content: "baz"
            }]))].flat();

Tests:

Filter + Set
const seen = new Set(); const deduplicatedArray1 = array.filter(item => { if (seen.has(item.id)) { return false; } seen.add(item.id); return true; });
Array from Map
const deduplicatedArray2 = [ ...new Map(array.map(item => [item.id, item])).values() ];
Naive Filter
const deduplicatedArray3 = array.filter((item, index, self) => index === self.findIndex(obj => obj.id === item.id) );
Object lookup
const deduplicatedArray4 = []; const seen = {}; for (const item of array) { if (!seen[item.id]) { deduplicatedArray4.push(item); seen[item.id] = true; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Filter + Set
Array from Map
Naive Filter
Object lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Linux

View result in a separate tab

Test name	Executions per second
Filter + Set	15587.9 Ops/sec
Array from Map	11636.0 Ops/sec
Naive Filter	27.3 Ops/sec
Object lookup	16008.3 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided tests four different strategies for deduplicating an array of objects in JavaScript based on a specific property (in this case, the `id` property). Each strategy is implemented as a distinct test case, allowing for a comparison of their performance in terms of executions per second.

### Strategies Compared

1. **Filter + Set**:
   - **Code**: 
     ```javascript
     const seen = new Set();
     const deduplicatedArray1 = array.filter(item => {
       if (seen.has(item.id)) {
         return false;
       }
       seen.add(item.id);
       return true;
     });
     ```
   - **Pros**: 
     - Uses a `Set` for a fast lookup (O(1) on average) to check if an object has already been seen.
     - Maintains the order of elements as they appear in the original array.
   - **Cons**: 
     - Requires additional memory to store the `Set`, which can be significant for large datasets.

2. **Array from Map**:
   - **Code**: 
     ```javascript
     const deduplicatedArray2 = [...new Map(array.map(item => [item.id, item])).values()];
     ```
   - **Pros**: 
     - Efficiently deduplicates by entering objects into a `Map`, where the key is the `id`. The `Map` automatically handles duplicates.
     - Easy to read and understand.
   - **Cons**: 
     - Requires memory for the `Map` object, and accessing keys may be less straightforward than using a `Set`.

3. **Naive Filter**:
   - **Code**: 
     ```javascript
     const deduplicatedArray3 = array.filter((item, index, self) => 
       index === self.findIndex(obj => obj.id === item.id)
     );
     ```
   - **Pros**: 
     - Simple and direct implementation, making it easy to understand.
   - **Cons**: 
     - Results in O(n^2) time complexity because for each item, it searches through the entire array with `findIndex`, making it inefficient for large datasets.

4. **Object Lookup**:
   - **Code**: 
     ```javascript
     const deduplicatedArray4 = [];
     const seen = {};
     
     for (const item of array) {
       if (!seen[item.id]) {
         deduplicatedArray4.push(item);
         seen[item.id] = true;
       }
     }
     ```
   - **Pros**: 
     - This method offers a good balance of speed and memory efficiency by using a simple object to track seen items. Lookups and insertions to the object are fast.
     - Maintains order of the elements.
   - **Cons**: 
     - While fast, implementing deduplication via direct object properties may lead to issues if `id` values are not unique or can lead to property name collisions.

### Performance Results
Based upon the provided execution results, the fastest method was **Object Lookup**, achieving around 16008 executions per second, followed by **Filter + Set** at approximately 15588 executions per second. **Array from Map** performed reasonably well at around 11636 executions per second, while the **Naive Filter** was significantly slower at about 27 executions per second. This indicates substantial performance differences based on the approach chosen.

### Considerations
When choosing a deduplication strategy, other considerations include:

- **Data Size**: For small arrays, even slower methods may perform adequately, but for larger data sets, efficiency in time complexity becomes critical.
- **Memory Usage**: While certain methods may perform better, they also require more memory, so understanding the trade-offs between speed and memory footprint is essential.
- **Use Case**: For scenarios where order matters, strategies that preserve original order (like all strategies except the Naive Filter) should be preferred.

### Alternatives
Other alternatives for deduplication might include using third-party libraries such as Lodash, which has a dedicated `_.uniqBy` function that handles deduplication smartly. Additionally, in a more functional programming style, one might consider leveraging techniques like RxJS or using iterators to produce less memory-intensive solutions. However, the trade-offs of readability, performance, and the additional weight of libraries must also be considered when choosing an approach.

Related benchmarks:

Dedup Array of Objects (4 strats) (version: 1)

Comparing performance of: Filter + Set vs Array from Map vs Naive Filter vs Object lookup

Created: 3 months ago by: Guest

Jump to the latest result

Filter + Set

Array from Map

Naive Filter

Object lookup

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):