Benchmark: lodash uniq vs Array.from(new Set()) vs spread new Set() vs for vs for memory optimized

HTML Preparation code:


<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js'></script>

Tests:

Spread
return [...new Set([1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7])]
use lodash
return _.uniq([1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]);
Array.from
return Array.from( new Set([1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]) );
For
const visited = {}; const uniques = []; const initial = [1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]; for(let i=0;i<initial.lenght;i++){ if(!visited[initial[i]]) { visited[initial[i]] = true; uniques.push(initial[i]); } } return uniques
For memory optimized
const visited = {}; const uniques = []; const initial = [1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]; for(let i=0;i<initial.lenght;i++){ if(!(initial[i] in visited)) { visited[initial[i]] = undefined; uniques.push(initial[i]); } } return uniques

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Spread
use lodash
Array.from
For
For memory optimized

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Windows

View result in a separate tab

For memory optimized

1390.7M/s

For

1390.3M/s

use lodash

5.4M/s

Spread

2.7M/s

Array.from

2.2M/s

View exact numbers

Test name	Executions per second
✓ For memory optimized	1,390,702,208 Ops/sec
For	1,390,301,824 Ops/sec
use lodash	5,422,524 Ops/sec
Spread	2,730,214 Ops/sec
Array.from	2,182,405 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmarking test case, specifically designed to compare the performance of different approaches for removing duplicates from an array.

**Approaches Compared**

Four approaches are compared in this benchmark:

1. **`Array.from(new Set([...]))`**: This approach uses the `Set` object and the spread operator (`...`) to create a new set from the input array, effectively removing duplicates.
2. **`.uniq()` from Lodash library**: This approach uses the `uniq()` function from the Lodash library, which removes duplicate values from an array while preserving order.
3. **Manual loop with `for` and `in` operators**: This approach uses a manual loop to iterate through the input array, checking for duplicates using the `in` operator on the `visited` object.
4. **Manual loop with `for` and `!` operators (memory optimized)**: This approach is similar to the previous one, but uses the logical negation operator (`!`) instead of `in`, which is optimized for performance.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **`Array.from(new Set([...]))`**:
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not be suitable for large datasets due to the overhead of creating a `Set`.
2. **`.uniq()` from Lodash library**:
	* Pros: Convenient, readable, and well-tested.
	* Cons: Adds external dependency (Lodash), may have performance overhead.
3. **Manual loop with `for` and `in` operators**:
	* Pros: Low overhead, easy to understand.
	* Cons: May be slower due to the use of the `in` operator, which has a higher constant factor than negation (`!`).
4. **Manual loop with `for` and `!` operators (memory optimized)**:
	* Pros: Optimized for performance, uses less memory.
	* Cons: More complex, harder to understand.

**Library and Special JS Features**

The benchmark uses the Lodash library for its `uniq()` function. The test cases do not use any special JavaScript features or syntax beyond what is considered standard.

**Other Alternatives**

Some alternative approaches that could be used in this benchmark include:

* Using `Map` instead of `Set`
* Using `Filter()` instead of manual loops
* Using `Array.prototype.reduce()` instead of manual loops

However, these alternatives may not provide the same level of performance or readability as the compared approaches.

**Benchmark Results**

The latest benchmark results show that the "For memory optimized" approach performs the best, followed closely by the `Array.from(new Set([...]))` approach. The Lodash-based approach is slower, while the manual loop with `for` and `in` operators is even slower due to the overhead of the `in` operator.

Please note that benchmark results can vary depending on the specific hardware, software configuration, and execution environment.

lodash uniq vs Array.from(new Set()) vs spread new Set() vs for vs for memory optimized (version: 0)

Comparing performance of: `Spread vs use lodash vs Array.from vs For vs For memory optimized`

Created: 2 years ago by: Guest

Go to the latest result

Spread

use lodash

Array.from

For

For memory optimized

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

lodash uniq vs Array.from(new Set()) vs spread new Set() vs for vs for memory optimized (version: 0)

Comparing performance of: Spread vs use lodash vs Array.from vs For vs For memory optimized

Created: 2 years ago by: Guest

Go to the latest result

Spread

use lodash

Array.from

For

For memory optimized

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Spread vs use lodash vs Array.from vs For vs For memory optimized`