Benchmark: Set ES2024 Method Benchmark

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const set1 = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]);
const set2 = new Set([3, 4, 5, 6, 7, 8, 9, 0, 11, 12]);

Tests:

Set.difference
const set3 = set1.difference(set2);
Set.symmetricDifference
const set3 = set1.symmetricDifference(set2);
Set.union
const set3 = set1.union(set2);
Set.intersection
const set3 = set1.intersection(set2);
Set.isSubsetOf
const sub = set1.isSubsetOf(set2);
Set.isSupersetOf
const sup = set1.isSupersetOf(set2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set.difference
Set.symmetricDifference
Set.union
Set.intersection
Set.isSubsetOf
Set.isSupersetOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set.difference	7697581.0 Ops/sec
Set.symmetricDifference	8099092.5 Ops/sec
Set.union	12444521.0 Ops/sec
Set.intersection	7806712.5 Ops/sec
Set.isSubsetOf	23251122.0 Ops/sec
Set.isSupersetOf	14654210.0 Ops/sec

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

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark titled "Set ES2024 Method Benchmark" aims to evaluate various performance aspects of JavaScript `Set` methods, which are used for set operations on collections of unique values. This specific benchmark includes comparison of six different operations provided by the `Set` object in JavaScript:

1. **Set.difference**
2. **Set.symmetricDifference**
3. **Set.union**
4. **Set.intersection**
5. **Set.isSubsetOf**
6. **Set.isSupersetOf**

The benchmark uses two initial sets, `set1` and `set2`, created from arrays of numbers. The performance is measured in terms of execution speed (executions per second) for each set operation.

### Benchmarked Methods

#### 1. **Set.difference**
- **Definition:** This operation returns a new `Set` containing all elements from `set1` that are not in `set2`.
- **Pros:** Useful for filtering out elements and identifying what is unique to the first set.
- **Cons:** If large sets are used, it may require significant memory and processing time.

#### 2. **Set.symmetricDifference**
- **Definition:** This operation gives a new `Set` containing elements that are in either `set1` or `set2`, but not in both.
- **Pros:** It can be helpful in scenarios where you need to find non-overlapping elements.
- **Cons:** Similar to set difference, it can consume more time and memory with larger datasets.

#### 3. **Set.union**
- **Definition:** Generates a new `Set` that contains all elements from both `set1` and `set2`.
- **Pros:** Efficiently combines two sets, ensuring all elements remain unique.
- **Cons:** If both sets are large, there is still a non-trivial computational cost.

#### 4. **Set.intersection**
- **Definition:** Returns a new `Set` containing only elements that are present in both `set1` and `set2`.
- **Pros:** Useful for identifying common elements quickly.
- **Cons:** Performance may vary based on the sizes of the input sets.

#### 5. **Set.isSubsetOf**
- **Definition:** Checks if all elements of `set1` are also in `set2`.
- **Pros:** Efficient for verifying relationships between sets.
- **Cons:** May not be performant for very large sets, as it requires comparing all elements.

#### 6. **Set.isSupersetOf**
- **Definition:** Tests whether `set1` contains all elements of `set2`.
- **Pros:** Similar to subset check, it's efficient in relationship validation.
- **Cons:** Again, performance can suffer with very large datasets.

### Latest Benchmark Results

The latest benchmark results provide valuable insights into the performance of these operations on a defined setup using Chrome 133 on Windows. The execution speeds (in executions per second) indicate that:

- `Set.isSubsetOf`: ~20.2 million executions/sec (fastest)
- `Set.isSupersetOf`: ~13.5 million executions/sec
- `Set.union`: ~11.4 million executions/sec
- `Set.symmetricDifference`: ~7.6 million executions/sec
- `Set.difference`: ~6.9 million executions/sec
- `Set.intersection`: ~6.9 million executions/sec

### Considerations and Alternatives

#### Considerations
- **Performance Aspects**: The choice of operation may lead to different performance implications based on the sizes of the sets being used and the nature of the data.
- **Memory Usage**: Some set operations may require additional memory overhead, potentially leading to performance trade-offs.
- **Applicability**: Users should choose the operations suited to their specific use case rather than opting for the most performant option generally.

#### Alternatives
- **Array Methods**: Similar functionality can be achieved using standard array methods like `filter()`, `concat()`, or custom utility functions, though they might not maintain unique values naturally as `Set` does.
- **Libraries**: Libraries like Lodash provide a rich set of utilities for collection and array manipulation, which may encapsulate set operations. However, these could come with a heavier footprint than native `Set` methods.
- **Immutable.js**: For applications needing immutable data structures, libraries like Immutable.js provide robust structures including Sets with their performance implications.

These aspects should encourage developers to explore how best to utilize JavaScript's `Set` methods in their work while weighing performance requirements against the needs of their specific applications.

Related benchmarks:

Set ES2024 Method Benchmark (version: 1)

Comparing performance of: Set.difference vs Set.symmetricDifference vs Set.union vs Set.intersection vs Set.isSubsetOf vs Set.isSupersetOf

Created: 2 months ago by: Registered User

Jump to the latest result

Set.difference

Set.symmetricDifference

Set.union

Set.intersection

Set.isSubsetOf

Set.isSupersetOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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