Benchmark: Unique Array: Lodash vs spread new Set vs reduce vs for - random data

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

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

Tests:

Array Unique
const { resultArray } = testArr.reduce((result, item) => { if(!result.resultMap[item]){ result.resultMap[item] = true; result.resultArray.push(item) } return result; }, {resultArray: [], resultMap: {}}); return resultArray;
For Loop
const resultArray = []; const resultMap = {}; for(let item of testArr) { if(!resultMap[item]){ resultMap[item] = true; resultArray.push(item) } } return resultArray;
Array from Set
[...new Set(testArr)]
Lodash Uniq
_.uniq(testArr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array Unique
For Loop
Array from Set
Lodash Uniq

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array Unique	246.6 Ops/sec
For Loop	262.9 Ops/sec
Array from Set	196.9 Ops/sec
Lodash Uniq	169.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark measures the performance of four different approaches to remove duplicates from an array of strings:

1.  **Array.from(new Set())**: This approach uses the `Set` data structure and the spread operator (`new Set`) to create a set of unique elements, which is then converted back into an array.
2.  **_.uniq() (Lodash)**: This approach uses the Lodash library's `uniq()` function to remove duplicates from the array.
3.  **for loop**: This approach manually iterates through the array using a traditional `for` loop, checking each element against an empty object (`{}`) to determine if it exists in the result set.
4.  **reduce()**: This approach uses the `reduce()` method on the array, accumulating unique elements in an object (`resultMap`) and pushing them onto a separate array (`resultArray`).

**Options Compared**

The benchmark compares these four approaches to see which one performs best:

*   **Array.from(new Set())**: Uses the built-in `Set` data structure and spread operator.
*   **_.uniq() (Lodash)**: Utilizes Lodash's utility function for removing duplicates.
*   **for loop**: Manually iterates through the array using a traditional `for` loop.
*   **reduce()**: Employes the `reduce()` method to accumulate unique elements.

**Pros and Cons**

Here are some pros and cons of each approach:

### Array.from(new Set())

Pros:

*   Fast and efficient, as it leverages the optimized performance of the built-in `Set` data structure.
*   Simple and concise code.

Cons:

*   Requires JavaScript version 15 or later to support the spread operator (`new Set()`).
*   May not work correctly in older browsers or environments that do not support `Set`.

### _.uniq() (Lodash)

Pros:

*   Widely supported, as it relies on Lodash's existing implementation.
*   Can be used with any version of JavaScript.

Cons:

*   Adds an external dependency (Lodash) and may increase bundle size.
*   May have a slightly higher overhead due to the additional function call.

### for loop

Pros:

*   Widely supported, as it is a traditional approach that works in most environments.
*   No dependencies or external libraries required.

Cons:

*   Manual iteration can be slower than optimized built-in methods.
*   Requires more code and logic to implement correctly.

### reduce()

Pros:

*   Fast and efficient, leveraging the optimized performance of the `reduce()` method.
*   Simple and concise code.

Cons:

*   Requires JavaScript version 15 or later to support the spread operator (`{resultArray: []}`).
*   May have a slightly higher overhead due to the additional function call.

**Library: Lodash**

The `_uniq()` function is part of the popular Lodash utility library, which provides a collection of functional programming helper functions. Lodash can be used to simplify code and improve performance in various JavaScript tasks.

**Special JS Feature/Syntax**

None mentioned in this specific benchmark. However, it's worth noting that some modern JavaScript features like `const` declarations, `let` and `var` hoisting, and the spread operator (`...`) are used throughout the benchmark.

**Other Alternatives**

If you're looking for alternatives to these approaches or want to explore other methods for removing duplicates from an array:

*   **Array.prototype.filter()**: This method can be used in combination with the `includes()` method to remove duplicates.
*   **Set.from() and Set.keys()**: These methods can be used to create a set of unique elements from an array, which can then be converted back into an array using `Array.from()`.
*   **Object.values() and Object.fromEntries()**: These methods can be used to transform an object with duplicate values into an array with unique values.

I hope this explanation helps you understand the JavaScript microbenchmark on MeasureThat.net!

Related benchmarks:

Unique Array: Lodash vs spread new Set vs reduce vs for - random data (version: 0)

Comparing performance of: Array Unique vs For Loop vs Array from Set vs Lodash Uniq

Created: 3 years ago by: Registered User

Jump to the latest result

Array Unique

For Loop

Array from Set

Lodash Uniq

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