Benchmark: Lodash uniqBy vs Set with Array of object

HTML Preparation code:

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

Script Preparation code:

var myArr = Array.from({
    length: 16000
}, () => ({ value: Math.floor(Math.random() * 1000) }));

var myCopy = null;

Tests:

Lodash uniqBy
myCopy = _.uniqBy(myArr, 'value').map(({ value }) => value);
new Set() Destructuring
myCopy = [...new Set(myArr.map(({ value }) => value))]
uniq for loop
var seen = {}; var out = []; const len = myArr.length; var j = 0; for (var i = 0; i < len; i += 1) { var item = myArr[i].value; if (seen[item] !== 1) { seen[item] = 1; out[j++] = item; } } myCopy = out;
uniq by forEach
var result = []; myArr.forEach((item) => { if (result.indexOf(item.value) < 0) { result.push(item.value); } }); myCopy = result;
uniq by filter
var mapMyArr = myArr.map(({ value }) => value); myCopy = mapMyArr.filter((value, index, array) => array.indexOf(value) === index);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash uniqBy
new Set() Destructuring
uniq for loop
uniq by forEach
uniq by filter

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 days ago)

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

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash uniqBy	7751.4 Ops/sec
new Set() Destructuring	7328.7 Ops/sec
uniq for loop	29507.6 Ops/sec
uniq by forEach	522.7 Ops/sec
uniq by filter	284.2 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.

**Benchmark Description**

The benchmark tests four different approaches to remove duplicates from an array of objects while preserving the original order:

1. **Lodash `uniqBy`**: Uses Lodash's `uniqBy` function, which removes duplicate elements from an array based on a unique function.
2. **`new Set()` with Array destructuring**: Uses a `Set` data structure to remove duplicates and then uses array destructuring to create a new array.
3. **For loop**: Iterates through the array using a traditional for loop and checks each element against a set of seen values to avoid duplicates.
4. **`forEach()` with `indexOf()`**: Iterates through the array using `forEach()` and checks if an element is already present in the array using `indexOf()`.

**Options Compared**

The four options are compared in terms of their performance, efficiency, and readability.

* **Lodash `uniqBy`**: Pros: concise, readable, and easy to use. Cons: may not be as efficient as other approaches.
* **`new Set()` with Array destructuring**: Pros: efficient, straightforward, and easy to understand. Cons: requires a slight learning curve for those unfamiliar with sets.
* **For loop**: Pros: well-known, familiar algorithm. Cons: verbose, error-prone, and less readable than the other options.
* **`forEach()` with `indexOf()`**: Pros: concise, readable. Cons: may not be as efficient as other approaches.

**Libraries and Special JS Features**

The benchmark uses Lodash's `uniqBy` function, which is a utility library that provides a simple way to remove duplicates from an array based on a unique function.

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

**Benchmark Preparation Code**

The preparation code generates an array of 16,000 objects with random values and copies the array to ensure correct results. The `myCopy` variable is initialized to null, which will be populated with the result of each benchmarking approach.

**HTML Preparation Code**

The HTML code includes a link to Lodash's CDN, which loads the necessary library for the `uniqBy` function.

**Other Alternatives**

There are other approaches to removing duplicates from an array in JavaScript, such as:

* Using `Array.prototype.filter()` and checking if each element is already present in the array.
* Using `Array.prototype.every()` and checking if each element meets a certain condition.
* Using a recursive approach with a helper function.

These alternatives may have their own trade-offs in terms of performance, efficiency, and readability.

Related benchmarks:

Lodash uniqBy vs Set with Array of object (version: 4)

Lodash uniqBy vs [...new Set()]

Comparing performance of: Lodash uniqBy vs new Set() Destructuring vs uniq for loop vs uniq by forEach vs uniq by filter

Created: 3 years ago by: Registered User

Jump to the latest result

Lodash uniqBy

new Set() Destructuring

uniq for loop

uniq by forEach

uniq by filter

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