Benchmark: Set from array vs .add

Tests:

new Set
let sourceArray = [] for(let i=1; i<1000000; i++) { sourceArray.push(i) } const setObject = new Set(sourceArray)
.add
const setObject = new Set() for(let i=1; i<1000000; i++) { setObject.add(i) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Set
.add

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The JSON benchmark provided compares two different approaches for creating a `Set` in JavaScript: initializing a `Set` using an array versus adding elements individually using the `.add()` method. The goal is to measure the performance of these two methods in terms of how quickly they execute.

### Approaches Compared

1. **Creating a Set from an Array (`new Set(sourceArray)`):**
   - **Benchmark Definition:**
     ```javascript
     let sourceArray = [];
     for (let i = 1; i < 1000000; i++) {
         sourceArray.push(i);
     }
     const setObject = new Set(sourceArray);
     ```
   - **Test Name:** `new Set`
   - **Explanation:** This method takes an existing array (`sourceArray`) and directly initializes a `Set` object with it. Under the hood, the `Set` constructor iterates through the array and adds each element to the `Set`.

2. **Adding Elements Individually (`setObject.add(i)`):**
   - **Benchmark Definition:**
     ```javascript
     const setObject = new Set();
     for (let i = 1; i < 1000000; i++) {
         setObject.add(i);
     }
     ```
   - **Test Name:** `.add`
   - **Explanation:** In this method, an empty `Set` is created first, and elements are added one by one using the `.add()` method. This approach involves a separate add operation for each element.

### Performance Results

From the benchmark results:
- **`.add`:** Executed 5.59 executions per second.
- **`new Set`:** Executed 4.64 executions per second.

### Pros and Cons

#### Method 1: `new Set(sourceArray)`

**Pros:**
- **Simplicity and Conciseness:** This method is very straightforward and can be written in fewer lines of code.
- **Efficiency for Bulk Operations:** If you have a large amount of data, initializing a `Set` directly from an array might be faster due to internal optimizations.

**Cons:**
- **Memory Overhead:** If the initial array is large, it might consume more memory upfront since it creates the entire array before passing it to the `Set` constructor.

#### Method 2: `.add`

**Pros:**
- **Incremental Addition:** This method allows adding elements one at a time, which can be useful if you're receiving data in chunks or dynamically during execution.
- **Control Over Insertions:** You can add conditions for inserting values into the `Set`, which might be useful based on the application logic.

**Cons:**
- **Performance Overhead:** This approach tends to be slower, particularly when dealing with a large number of items since it involves repeated method calls, which can add overhead for each insertion.
- **More Code:** Requires more lines of code and can be less readable compared to the first approach when dealing with large datasets.

### Other Considerations

- **Browser and Environment:** The benchmark results are specific to a test run in Google Chrome version 129 on Windows 10. Different browsers and environments may yield different performance results due to varying JavaScript engines (like V8 for Chrome).
- **Scope of Tests:** The specific range of numbers (1 to 999,999) is used for comparison, which may not represent all use cases. Benchmarks can vary significantly with different input sizes or types.
- **Garbage Collection:** The performance could also be affected by the JavaScript engine's garbage collection, especially in longer-running scripts or when large amounts of data are being created and destroyed.

### Alternatives

Besides the methods tested, one could consider:
- **Using a third-party library**: Libraries such as Lodash can simplify operations but may introduce their own overhead.
- **Typed Arrays or Other Data Structures**: Depending on the use case, alternatives like arrays, objects, or Maps may offer better performance or semantics in specific scenarios.
- **Batching Operations**: If adding many items to a `Set`, batching insertions in some way or handling them through websockets or streams may provide advantages in reducing overhead and improving performance.

In summary, the choice between `new Set(sourceArray)` and repeatedly using `.add()` depends on the specific needs of your application concerning performance, memory usage, and code readability.

Latest run results:

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

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
new Set	4.6 Ops/sec
.add	5.6 Ops/sec

Related benchmarks:

Set from array vs .add (version: 0)

Comparing performance of: new Set vs .add

Created: 24 days ago by: Guest

Jump to the latest result

new Set

.add

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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