Benchmark: unique set or object

Script Preparation code:

var a = new Array(10000).fill(0).map(() => Math.floor(Math.random() * 10000));
var b = new Array(10000).fill(0).map(() => Math.floor(Math.random() * 10000).toString(32));

Tests:

Set number
var u = [...new Set(a).keys()]
Object number
var u = Object.values(a.reduce( (res, k) => { res[k] ??= k; return res; },{} ));
object filter number
const f = new Set(); return a.filter((v) => (f.has(v) ? false : f.add(v)));
Set string
var u = [...new Set(b).keys()]
Object string
var u = Object.values(b.reduce( (res, k) => { res[k] ??= k; return res; },{} ));
object filter string
const f = new Set(); return b.filter((v) => (f.has(v) ? false : f.add(v)));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set number
Object number
object filter number
Set string
Object string
object filter string

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set number	3685.0 Ops/sec
Object number	3575.7 Ops/sec
object filter number	3104.1 Ops/sec
Set string	2990.0 Ops/sec
Object string	804.5 Ops/sec
object filter string	2513.7 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark definition and test cases for you.

**Benchmark Definition**

The benchmark definition is represented by a JSON object that defines a JavaScript function to be executed on a fixed input data set. The main components of this definition are:

*   `Script Preparation Code`: This code snippet initializes an array, `a` or `b`, with 10,000 random integer values (in hexadecimal representation for `b`). Both arrays have the same size and properties, but they contain different types of numbers: integers in `a` and hexadecimal strings in `b`.
*   `Html Preparation Code`: This field is empty in this case.

The goal of the benchmark definition seems to be measuring performance across several JavaScript methods for set operations (using `Set`, objects with string keys), filtering, and iteration.

**Test Cases**

There are six test cases defined:

1.  **Set Number**: Uses the built-in `Set` object to convert an array into a unique collection of values, then extracts its keys.
2.  **Object Number**: Utilizes the `Object.values()` method in combination with the `reduce()` function to create an object from the array and then extract its keys.
3.  **Object Filter Number**: Iterates over the array using the `filter()` method in combination with a set to filter out unique values, then extracts its keys.
4.  **Set String**: Similar to Set Number but uses hexadecimal strings for values.
5.  **Object String**: Similar to Object Number but uses hexadecimal strings for values.
6.  **Object Filter String**: Similar to Object Filter Number but uses hexadecimal strings for values.

**Library and Special Features**

*   The `Set` object is used across multiple test cases, as it provides an efficient way to work with unique collections of values.
*   There's no specific mention of any libraries beyond the built-in JavaScript features like `Set`, `Object.values()`, `Object.keys()`, or methods for iterating over data (e.g., `filter()`).
*   There are no special features in this benchmark, as it focuses on basic operations using standard JavaScript data structures.

**Performance Considerations**

Performance differences can arise from various factors:

*   **Iteration Methods**: The choice between set-based (`Set`), object-based (`Object.values()` and `Object.keys()`), or filter methods (like `filter()`) might impact performance because each has its own overhead.
*   **Data Structure Access Patterns**: Directly accessing the elements of an array versus using an iterator to extract keys might affect execution speed due to different operations being performed on the data structure itself.

**Alternatives**

For benchmarking set-based, object-based, or filter methods, consider alternatives:

1.  **Benchmarking libraries and frameworks**: Some libraries offer built-in functionality for these operations that can be used in your benchmarks.
2.  **Custom test code**: You might create custom functions or scripts tailored to specific performance testing scenarios.
3.  **Benchmarking tools**: There are various benchmarking tools available, both online and offline, which can help you measure performance under different conditions.

Keep in mind that the approach you choose should align with your project's requirements, data structures, and expected use cases.

Related benchmarks:

unique set or object (version: 6)

Comparing performance of: Set number vs Object number vs object filter number vs Set string vs Object string vs object filter string

Created: 2 years ago by: Registered User

Jump to the latest result

Set number

Object number

object filter number

Set string

Object string

object filter string

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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