Benchmark: Methods to remove duplicates from array x2

Script Preparation code:

var array = [];
for (let i = 0; i < 100000; i++) {
   array.push(Math.floor((Math.random() * 10) + 1));
}

Tests:

Using indexOf
array.filter((item, index) => array.indexOf(item) != index);
Using lastIndexOf
array.filter((item, index) => array.lastIndexOf(item) != index);
Using a Set
[...new Set(array)]
Using a Map
const deduped = new Map(); array.forEach((v) => { if (!deduped.has(v)) { deduped.set(v, v); } }); return Array.from(deduped.values());

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using indexOf
Using lastIndexOf
Using a Set
Using a Map

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

I'll break down the explanation into smaller parts to make it easier to understand.

**Benchmark Definition and Script Preparation Code**

The benchmark is defined in JSON format, which includes:

* `Name`: A human-readable name for the benchmark (in this case, "Methods to remove duplicates from array x2").
* `Description`: An optional description of the benchmark (not provided in this example).
* `Script Preparation Code`: A JavaScript code snippet that prepares the input data for the benchmark. In this case, it creates an empty array and populates it with 100,000 random integers between 1 and 10.

**Individual Test Cases**

The test cases are defined as an array of objects, each representing a single test to be executed:

* Each object has two properties:
	+ `Benchmark Definition`: A JavaScript code snippet that defines the specific operation to be performed on the input data. In this case, there are four test cases:
		- Using `indexOf`
		- Using `lastIndexOf`
		- Using a Set
		- Using a Map
* `Test Name`: A human-readable name for each test case.

**Options Compared**

The test cases compare the performance of different approaches to remove duplicates from an array:

1. **Using `indexOf`**: This approach uses the `indexOf` method to check if an element is present in the array.
2. **Using `lastIndexOf`**: This approach uses the `lastIndexOf` method to find the index of the last occurrence of an element.
3. **Using a Set**: This approach converts the array to a Set data structure, which automatically removes duplicates.
4. **Using a Map**: This approach creates a Map object and iterates through the array, adding each unique value as a key-value pair.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

* **Using `indexOf`**:
	+ Pros: Simple to implement, works well for small arrays.
	+ Cons: Can be slow for large arrays, as it has to search the entire array for each element.
* **Using `lastIndexOf`**:
	+ Pros: Similar to using `indexOf`, but can be slightly faster due to cache locality.
	+ Cons: Still requires searching the entire array, making it less efficient than Set or Map approaches.
* **Using a Set**:
	+ Pros: Fast and efficient, as Sets automatically remove duplicates and have an average time complexity of O(1).
	+ Cons: May require additional memory, depending on the size of the input data.
* **Using a Map**:
	+ Pros: Similar to using a Set, but can also preserve the original order of elements.
	+ Cons: Requires more memory than Sets, especially for large inputs.

**Other Considerations**

When choosing an approach, consider the following factors:

* **Performance**: If speed is critical, using a Set or Map may be a better choice. For smaller arrays, `indexOf` and `lastIndexOf` might suffice.
* **Memory**: If memory usage is a concern, using a Set or Map may not be suitable due to increased memory requirements.
* **Preserving order**: If preserving the original order of elements is important, using a Map may be a better choice.

**Browser-Specific Considerations**

The benchmark results are specific to Chrome 114 on a Macintosh desktop with macOS 10.15.7. This means that the performance measurements might not generalize well to other browsers or environments.

As for special JavaScript features or syntax, there's no mention of any specific features being used in this benchmark.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Using indexOf	84.1 Ops/sec
Using lastIndexOf	66.8 Ops/sec
Using a Set	571.9 Ops/sec
Using a Map	394.8 Ops/sec

Related benchmarks:

Methods to remove duplicates from array x2 (version: 0)

Comparing performance of: Using indexOf vs Using lastIndexOf vs Using a Set vs Using a Map

Created: one year ago by: Guest

Jump to the latest result

Using indexOf

Using lastIndexOf

Using a Set

Using a Map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):