Benchmark: Make array of primitives unique

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * max);
}

var arr = [];
for(let i = 0; i < 10000; i++) {
	  arr.push(getRandomInt(1000));
}

Tests:

Array.findIndex
const compare = (a,b) => a === b; arr.filter((item, idx) => arr.findIndex(compare) === idx);
Array.indexOf
arr.filter((item, idx) => arr.indexOf(item) === idx);
Array.from(new Set(array))
Array.from(new Set(arr));
Object-filter
const obj = {}; arr.filter((item) => { if(!obj[item]){ obj[item] = true; return true; } return false; });
Object-values
Object.values(arr.reduce((acc, item) => { if(!acc[item]){ acc[item] = item; } return acc; }, {}));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.findIndex
Array.indexOf
Array.from(new Set(array))
Object-filter
Object-values

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0

Browser/OS: Firefox 126 on Windows

View result in a separate tab

Test name	Executions per second
Array.findIndex	80.4 Ops/sec
Array.indexOf	117.7 Ops/sec
Array.from(new Set(array))	4068.0 Ops/sec
Object-filter	9752.6 Ops/sec
Object-values	10600.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmarking test case on MeasureThat.net. The benchmark measures the performance of different approaches to filter an array and check if an element is unique.

**Test Case Options**

There are four test cases:

1. **Array.findIndex**: This approach uses the `findIndex` method to find the index of the first occurrence of a specified element in the array.
2. **Array.indexOf**: This approach uses the `indexOf` method to find the index of the first occurrence of a specified element in the array.
3. **Array.from(new Set(array))**: This approach converts the array to a set and then uses the `from()` method to create a new array from the set.
4. **Object-filter**: This approach uses an object to keep track of unique elements and filters the array based on this object.
5. **Object-values**: This approach uses the `reduce()` method to reduce the array to an object, where each key is a unique element in the array.

**Pros and Cons of Each Approach**

1. **Array.findIndex**:
	* Pros: Efficient use of iteration, simple implementation.
	* Cons: May have higher overhead due to using a separate index calculation.
2. **Array.indexOf**:
	* Pros: Simple and well-supported by most browsers.
	* Cons: May be slower than `findIndex` due to the need for an additional lookup.
3. **Array.from(new Set(array))**:
	* Pros: Eliminates duplicates, easy to implement.
	* Cons: Creates a new set and array, which can be memory-intensive.
4. **Object-filter**:
	* Pros: Efficient use of iteration, simple implementation.
	* Cons: May have higher overhead due to using an object for duplicate detection.
5. **Object-values**:
	* Pros: Elegant solution using `reduce()` method.
	* Cons: May be slower than other approaches due to the need for additional processing.

**Library and Special JS Feature**

None of the test cases explicitly use any libraries or special JavaScript features beyond the standard ECMAScript syntax.

**Other Alternatives**

Alternative approaches to filtering an array could include:

* Using a `Map` instead of an object for duplicate detection.
* Implementing a custom sorting algorithm to eliminate duplicates.
* Using a specialized library like Lodash or Underscore.js for array manipulation.
* Utilizing WebAssembly (WASM) for performance-critical applications.

**Benchmark Results Interpretation**

The benchmark results provide the following insights:

* The "Object-values" approach is the fastest, followed closely by "Array.findIndex".
* The "Object-filter" approach is slower than both of these but still relatively efficient.
* The "Array.from(new Set(array))" approach is slower due to the additional memory allocation and processing required.

Keep in mind that the performance differences between these approaches may vary depending on the specific use case, data size, and browser/interpreter variations.

Related benchmarks:

Make array of primitives unique (version: 1)

Comparing performance of: Array.findIndex vs Array.indexOf vs Array.from(new Set(array)) vs Object-filter vs Object-values

Created: 3 years ago by: Registered User

Jump to the latest result

Array.findIndex

Array.indexOf

Array.from(new Set(array))

Object-filter

Object-values

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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