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: one year 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

Test name	Executions per second
Spread	2730213.8 Ops/sec
use lodash	5422524.0 Ops/sec
Array.from	2182405.0 Ops/sec
For	1390301824.0 Ops/sec
For memory optimized	1390702208.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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.

Related benchmarks:

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: one year ago by: Guest

Jump to the latest result

Spread

use lodash

Array.from

For

For memory optimized

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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