Benchmark: set add vs map - MeasureThat.net

Script Preparation code:

var arr = [];
var count = 100000;
for(var i = 0; i<count; i++)
{
  arr.push(i);
}

Tests:

set add
const folderSet = new Set() arr.forEach((f) => { folderSet.add(f) })
map
const result = arr.map((f) => f) var end = [...new Set(result)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
set add
map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested, compared, and the pros/cons of each approach.

**Benchmark Overview**

The benchmark measures the performance difference between two approaches: using a `Set` data structure with the `add()` method (known as "set add") versus using the `map()` function followed by the spread operator (`new Set()`) to achieve similar functionality (known as "map").

**Script Preparation Code**

The script preparation code creates an empty array `arr` and populates it with 100,000 elements. This is done to ensure that both test cases have a large dataset to work with.

```javascript
var arr = [];
var count = 100000;
for (var i = 0; i < count; i++) {
    arr.push(i);
}
```

**Options Compared**

The two options being compared are:

1. **Set Add**: Using the `add()` method of a `Set` data structure to add elements to it.
2. **Map + Set**: Using the `map()` function to transform the array into an array of values, and then creating a new `Set` from this array using the spread operator (`new Set()`).

**Pros and Cons**

### Set Add

Pros:

* Efficient use of memory: `Set` stores unique elements, which can lead to better cache locality and faster lookup times.
* Simple implementation: Adding an element to a `Set` is typically a constant time operation.

Cons:

* Limited functionality: `Set` only provides basic methods like `add()`, `has()`, and `size`. More complex operations might require converting the `Set` back into an array or using external libraries.
* Potential performance impact for large datasets: Depending on the JavaScript engine, adding many elements to a `Set` can be slow due to the overhead of creating and managing the internal data structure.

### Map + Set

Pros:

* More flexible: The `map()` function allows for more complex transformations, and converting the result to a `Set` provides a way to remove duplicates.
* Better handling of large datasets: Converting an array to a `Set` can be faster than repeatedly adding elements using `add()`, as it avoids the overhead of managing a growing internal data structure.

Cons:

* More memory-intensive: Creating a new `Set` from an array requires additional memory allocations and copies, which can impact performance.
* More complex implementation: The `map()` function adds an extra step, making the overall code more complicated.

**Library**

In this benchmark, no specific library is used. However, if you're interested in exploring other approaches or optimizing your code further, you might consider using libraries like Lodash or a custom utility function for set operations.

**Special JavaScript Features/Syntax**

There are no special JavaScript features or syntax being tested in this benchmark. Both `Set` and the `map()` function are standard JavaScript constructs.

**Alternatives**

Other approaches to compare could include:

* Using an array with `filter()` to remove duplicates
* Utilizing a library like Lodash's `uniqBy()` function
* Implementing a custom, more efficient algorithm for set operations (e.g., using a trie data structure)

Keep in mind that the choice of approach depends on your specific use case and performance requirements. This benchmark provides a general comparison of two common methods, but you may need to experiment with different approaches to find the best fit for your application.

Latest run results:

Run details: (Test run date: 5 years ago)

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

Browser/OS: Chrome 78 on Mac OS X 10.15.1

View result in a separate tab

Test name	Executions per second
set add	108.8 Ops/sec
map	103.0 Ops/sec

Related benchmarks:

set add vs map (version: 0)

Comparing performance of: set add vs map

Created: 5 years ago by: Guest

Jump to the latest result

set add

map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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