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

Set number

4K/s

Object number

4K/s

object filter number

3K/s

Set string

3K/s

object filter string

3K/s

Object string

804/s

View exact numbers

Test name	Executions per second
✓ Set number	3,685 Ops/sec
Object number	3,576 Ops/sec
object filter number	3,104 Ops/sec
Set string	2,990 Ops/sec
object filter string	2,514 Ops/sec
Object string	804 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.

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

Go 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):

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

Go 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):

Related benchmarks

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