Benchmark: Trey - unique array

Script Preparation code:

globalThis.nonUnique = ['one', 'two', 'three', 'three', 'four', 'four', 'five', 'six', 'seven', 'eight', 'nine'];

Tests:

Reduce
Object.keys(globalThis.nonUnique.reduce((acc, item) => { if (!acc[item]) { acc[item] = true }; return acc; }, {}));
Set
Array.from(new Set(globalThis.nonUnique));
Filter
globalThis.nonUnique.filter((value, index, array) => { return array.indexOf(value) === index; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Set
Filter

Fastest: N/A

Slowest: N/A

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/113.0.0.0 Safari/537.36

Browser/OS: Chrome 113 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Reduce	1737006.2 Ops/sec
Set	1434779.1 Ops/sec
Filter	3533902.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

The provided JSON represents a benchmark test case on MeasureThat.net, where users can create and run JavaScript benchmarks. The benchmark is designed to measure the performance of three different approaches: reducing an object using `reduce()`, creating a set from an array using `Set` constructor, and filtering an array using `filter()` method.

**Options being compared:**

1. **Reduce**: This approach uses the `reduce()` method to create an object with unique keys based on the values in the input array `globalThis.nonUnique`. The `reduce()` method iterates through the array, accumulating a result object where each key is a value from the array and its corresponding value is set to `true`.
2. **Set**: This approach uses the `Set` constructor to create a set from the input array `globalThis.nonUnique`. A set in JavaScript is an unordered collection of unique values.
3. **Filter**: This approach uses the `filter()` method to create a new array containing only the elements that pass the test implemented by the provided function.

**Pros and Cons:**

* **Reduce**: Pros:
	+ It can be more memory-efficient since it creates an object with references to the original values, rather than creating a new set or array.
	+ It has better cache locality since it iterates through the array in order.
* Cons:
	+ It may have slower performance due to the overhead of iterating through the entire array.
* **Set**: Pros:
	+ It is often faster than `reduce()` since sets are implemented as hash tables, which provide O(1) lookup time.
	+ It can be more memory-efficient since it doesn't create a large object with references to values.
* Cons:
	+ It may not have the same cache locality as `reduce()`.
	+ It requires additional memory for storing the set data structure.
* **Filter**: Pros:
	+ It is often faster than `reduce()` since it only iterates through the array once and can stop early if the predicate function returns false.
	+ It can be more memory-efficient since it doesn't create a large object with references to values.
* Cons:
	+ It may have slower performance due to the overhead of iterating through the entire array.
	+ It requires additional memory for storing the filtered array.

**Library and purpose:**

The `Set` constructor is a built-in JavaScript library that provides an efficient way to store unique values. It is implemented as a hash table, which allows for fast lookup, insertion, and deletion of elements.

**Special JS feature or syntax:**

None mentioned in this benchmark.

**Other alternatives:**

If you're looking for alternative approaches to these benchmarks, here are some options:

* Instead of using `reduce()`, you could use `Array.prototype.forEach()` with a callback function that sets the value at each index.
* Instead of using `Set` constructor, you could implement your own set data structure using arrays and hash tables.
* Instead of using `filter()`, you could implement your own filtering algorithm using loops and conditional statements.

Keep in mind that these alternatives may have different performance characteristics and trade-offs.

Related benchmarks:

Trey - unique array (version: 0)

Comparing performance of: Reduce vs Set vs Filter

Created: one year ago by: Guest

Jump to the latest result

Reduce

Set

Filter

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