Benchmark: Set vs Filter vs _.uniq for unique

Script Preparation code:

var array = Array.from({length: 40}, () => Math.floor(Math.random() * 140));

Tests:

Set spread
const f = [... new Set(array)]
Array from set
const s = new Set(array) const l = Array.from(s)
Filter
const b = array.filter((i,index) => array.indexOf(i)=== index)
_.uniq
const u = _.uniq(array)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set spread
Array from set
Filter
_.uniq

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark measures the performance of three different approaches to remove duplicates from an array: `Set` spread, `Array.from(set)`, and the `_.uniq()` function from the Lodash library.

**Options Compared**

1. **Set spread**: This approach uses the spread operator (`...`) to create a new set from the input array. The set data structure automatically removes duplicates.
2. **Array from set**: This approach creates a new set from the input array, and then uses `Array.from()` to convert it back into an array.
3. **_.uniq()**: This is a function from the Lodash library that takes an array as input and returns a new array with duplicates removed.

**Pros and Cons**

1. **Set spread**:
	* Pros: Efficient use of JavaScript's built-in set data structure, minimal overhead.
	* Cons: May not work correctly if the input array contains non-comparable values (e.g., strings vs numbers).
2. **Array from set**:
	* Pros: Works with any iterable, including arrays and sets.
	* Cons: Involves two function calls, which can be slower than a single operation.
3. **_.uniq()**:
	* Pros: Robust implementation that handles various edge cases, such as null or undefined values.
	* Cons: Requires an external library (Lodash), may incur additional overhead.

**Library and Special JS Feature**

The benchmark uses the `_.uniq()` function from Lodash, which is a popular utility library for JavaScript. The `_` symbol refers to the global scope in Node.js environments, where Lodash is often required.

There are no special JavaScript features or syntaxes used in this benchmark.

**Other Alternatives**

Besides the three options mentioned above, other approaches to remove duplicates from an array include:

1. Using a `Map` data structure and iterating over its keys.
2. Using a regular expression with the `match()` method.
3. Implementing a custom algorithm using bitwise operations or other techniques.

However, these alternatives may not be as efficient or convenient as the three options compared 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/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set spread	1360242.6 Ops/sec
Array from set	1301836.1 Ops/sec
Filter	583562.9 Ops/sec
_.uniq	1540017.1 Ops/sec

Related benchmarks:

Set vs Filter vs _.uniq for unique (version: 0)

Comparing performance of: Set spread vs Array from set vs Filter vs _.uniq

Created: one year ago by: Guest

Jump to the latest result

Set spread

Array from set

Filter

_.uniq

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