Benchmark: uniq objects array

Script Preparation code:

function generateRandomObjects(count) {
    const getRandomString = (length = 5) =>
        Math.random().toString(36).substring(2, 2 + length);

    return Array.from({
        length: count
    }, () => ({
        item: getRandomString(),
        descr: getRandomString(),
    }));
}

// Пример использования:
const randomObjects = generateRandomObjects(3000);
console.log(randomObjects);

Tests:

Set and ForOf
const uniqItems = new Set(); const items = []; for (const element of randomObjects) { const key = `${element.item} - ${element.descr}`; if (!uniqItems.has(key)) { items.push(element); uniqItems.add(key); } }
Map
const items = Array.from( new Map( randomObjects.map(i => [`${i.item} - ${i.descr}`, { item: i.item, descr: i.descr }]) ).values() );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set and ForOf
Map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 25 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set and ForOf	6114.2 Ops/sec
Map	4731.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 25 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided is focused on evaluating the performance of different methods for filtering unique objects from an array in JavaScript. The test specifically examines two different approaches to achieve this: using a `Set` in conjunction with a `for...of` loop and using a `Map`. Here's a detailed breakdown of the benchmark, the methods compared, and their pros and cons.

### Benchmark Description

1. **Test Cases**:
   - **Set and ForOf**:
     ```javascript
     const uniqItems = new Set();
     const items = [];
     for (const element of randomObjects) {
         const key = `${element.item} - ${element.descr}`;
         if (!uniqItems.has(key)) {
             items.push(element);
             uniqItems.add(key);
         }
     }
     ```
     - **Test Name**: Set and ForOf
     - **Description**: This method utilizes a `Set` to keep track of unique keys derived from the combination of the `item` and `descr` properties of each object. The `for...of` loop iterates through `randomObjects`, adding to the `items` array only those elements whose keys are not already present in the `Set`.

- **Map**:
     ```javascript
     const items = Array.from(
         new Map(
             randomObjects.map(i => [`${i.item} - ${i.descr}`, { item: i.item, descr: i.descr }])
         ).values()
     );
     ```
     - **Test Name**: Map
     - **Description**: This alternative approach makes use of a `Map` where each entry is created by mapping the `randomObjects` array to pairs of keys (the combined `item` and `descr`) and their corresponding objects. The unique objects are then extracted through the `values()` method of the `Map`, converted back into an array with `Array.from()`.

### Performance Results

Based on the execution results from the benchmark:

- **Set and ForOf** achieved **6114.19 executions per second**
- **Map** achieved **4731.93 executions per second**

### Comparison of Approaches

#### Pros and Cons

- **Set and ForOf**:
  - **Pros**:
    - Fast execution speed as indicated by the benchmark results.
    - Clear semantics; it’s straightforward to understand that you are checking for uniqueness and adding to the unique collection.
  - **Cons**:
    - Requires manual iteration, which might not be as concise as array or map methods.
  
- **Map**:
  - **Pros**:
    - Concise one-liner using the `map` and `Array.from` functions, which can lead to clearer code for some developers who favor functional programming styles.
    - Maintains insertion order which can be beneficial if the order of items is important.
  - **Cons**:
    - Slower execution speed compared to the Set approach in this benchmark.
    - Uses more memory overhead for maintaining the entries in the `Map`.

### Considerations

- **Memory Usage**: Both approaches create additional data structures (`Set` and `Map`), which can impact memory usage when working with large datasets.
- **Readability**: Depending on team familiarity with ES6 and functional programming constructs, one method may be preferred for readability over the other.
- **Browser Compatibility**: Both `Set` and `Map` are well-supported in modern browsers, but developers should consider compatibility when targeting older environments.

### Alternatives

In addition to these two methods, there are other approaches for achieving the same functionality:

- **Array.prototype.filter** combined with `Array.prototype.indexOf` could be employed to filter unique objects, though this would typically be less efficient as it requires scanning the array for each element, leading to higher time complexity.
  
- **Using Lodash or other libraries**: Libraries like Lodash provide utility functions such as `_.uniqBy()`, which can simplify the code further but add external dependencies.

- **Using plain object as a hash map**: Instead of `Set` or `Map`, one could use a plain object to track unique items, but this requires additional logic to ensure key uniqueness effectively.

These additional alternatives may prioritize different trade-offs between performance, readability, and external dependencies based on specific project requirements or developer preferences.

Related benchmarks:

uniq objects array (version: 1)

Comparing performance of: Set and ForOf vs Map

Created: 25 days ago by: Registered User

Jump to the latest result

Set and ForOf

Map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 25 days ago):