Benchmark: index vs map117 - MeasureThat.net

Script Preparation code:

var myArray = [];
for (let i = 0; i < 9999; i++) {
	myArray.push(i)
}

Tests:

1
let unique = Object.keys(myArray.reduce((acc, v) => { acc[v]=true; return acc }, {}))
2
let unique = [...new Set(myArray)];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1
2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year 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
1	6480.1 Ops/sec
2	2446.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark definition is represented by the JSON object:
```json
{
    "Name": "index vs map117",
    "Description": null,
    "Script Preparation Code": "var myArray = [];\r\nfor (let i = 0; i < 9999; i++) {\r\n\tmyArray.push(i)\r\n}\r\n",
    "Html Preparation Code": null
}
```
This JSON object defines a benchmark with the following characteristics:

* The name of the benchmark is "index vs map117".
* There's no description provided for the benchmark.
* The script preparation code creates an array `myArray` with 9999 elements, initialized using a `for` loop. This means that the array will be populated in-place without any additional memory allocations.

**Individual Test Cases**

The individual test cases are represented by two separate JSON objects:
```json
[
    {
        "Benchmark Definition": "let unique = Object.keys(myArray.reduce((acc, v) => { acc[v]=true; return acc }, {}))\r\n\r\n",
        "Test Name": "1"
    },
    {
        "Benchmark Definition": "let unique = [...new Set(myArray)];",
        "Test Name": "2"
    }
]
```
These two test cases are designed to compare the performance of two different approaches for finding unique elements in an array:

* Test Case 1 uses the `Object.keys()` function and the `reduce()` method to create an object with the unique elements. The resulting keys of this object represent the unique elements.
* Test Case 2 uses the spread operator (`...`) and the `Set` object to find the unique elements.

**Library: Set**

In both test cases, a `Set` object is used to store unique elements. A `Set` is a data structure that allows you to store multiple values without duplicates. It's implemented as an unordered collection of unique elements.

The purpose of using a `Set` in these test cases is to eliminate duplicate elements from the original array, making it easier to find unique elements.

**Pros and Cons**

Here are some pros and cons for each approach:

* **Test Case 1 (Object.keys() + reduce())**
	+ Pros:
		- Efficient memory usage since the `reduce()` method only creates a new object with the unique elements.
		- Allows for easy modification of the resulting object to suit specific use cases.
	+ Cons:
		- May have performance overhead due to the overhead of creating and traversing the object.
		- May not be suitable for very large datasets due to memory constraints.
* **Test Case 2 (Spread operator + Set())**
	+ Pros:
		- Fast and efficient, as it leverages the optimized implementation of the `Set` data structure.
		- Suitable for large datasets, as it uses a relatively lightweight data structure.
	+ Cons:
		- May incur additional memory overhead due to the creation of a new array with duplicates removed.

**Other Alternatives**

Some other alternatives for finding unique elements in an array include:

* Using `Array.prototype.filter()` and checking for truthiness: `myArray.filter(v => v)`. However, this approach may have performance overhead due to the overhead of creating and traversing the filtered array.
* Using a custom implementation using bitwise operations. However, this approach is less efficient and more complex.

In summary, the benchmark compares two different approaches for finding unique elements in an array: using `Object.keys()` and `reduce()` versus using the spread operator and a `Set`. The choice of which approach to use depends on performance requirements, memory constraints, and specific use cases.

Related benchmarks:

index vs map117 (version: 0)

Comparing performance of: 1 vs 2

Created: one year ago by: Guest

Jump to the latest result

1

2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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