Benchmark: find duplicates - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

function getModels() {
  const n = 1000;
  return new Array(n).fill(0).map((_, i) => ({
    id: i,
    value: Math.floor(Math.random() * n)
  }));
};

Tests:

map filter
const models = getModels(); const values = models.map((model) => model.value); models.forEach((model) => { const modelValue = model.value; const hasDuplicates = values.filter((value) => value === modelValue).length > 1; hasDuplicates && (model.isDuplicate = true); });
reduce
const models = getModels(); const valueMap = models.reduce((result, model) => (result[model.value] ? ++result[model.value] : result[model.value] = 1) && result, {}) models.forEach((model) => { valueMap[model.value] > 1 && (model.isDuplicate = true); });
lodash
const byValue = _.groupBy(getModels(), (model) => model.value); Object.values(byValue).forEach((models) => { const hasDuplicates = models.length > 1; hasDuplicates && models.forEach((model) => (model.isDuplicate = true)); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map filter
reduce
lodash

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net, where JavaScript microbenchmarks come to life.

**Benchmark Definition**

The provided JSON defines a benchmark for finding duplicates in an array. The test aims to measure which approach is most efficient: using the `map` and `filter` methods, the `reduce` method, or the `lodash` library's `groupBy` function.

**Approach 1: map filter**

This approach uses two separate methods: `map` and `filter`. The `map` method transforms each element in the array to a new value (in this case, the `value` property), while the `filter` method creates a new array with only the elements that match the condition (`value === modelValue`). The resulting array is then used to determine if there are any duplicates.

Pros:

* Simple and easy to understand
* No additional dependencies required

Cons:

* Two separate method calls, which can be slower than using a single method
* More memory usage due to creating two intermediate arrays

**Approach 2: reduce**

This approach uses the `reduce` method to create an object with values as keys and counts as values. The value for each key is incremented whenever that value appears in the array. Finally, the result is checked to see if there are any duplicates.

Pros:

* Single method call, which can be faster than using two separate methods
* Less memory usage since only a single intermediate object is created

Cons:

* Requires understanding of the `reduce` method and its usage
* May not be as readable or maintainable for some developers

**Approach 3: lodash**

This approach uses the `lodash` library's `groupBy` function to group the array elements by their values. The resulting grouped arrays are then checked to see if there are any duplicates.

Pros:

* Convenient and easy-to-use function from a popular library
* Can be faster than using a custom implementation

Cons:

* Additional dependency required (lodash)
* May not be suitable for all use cases or environments (e.g., older browsers)

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, object management, and more. The `groupBy` function in particular is useful for grouping elements by certain criteria.

Pros:

* Provides a convenient and efficient way to perform grouping operations
* Supports various data types and edge cases

Cons:

* Additional dependency required (lodash)
* May not be suitable for all use cases or environments (e.g., older browsers)

**Special JavaScript feature: async/await**

There is no apparent use of the `async/await` syntax in this benchmark. If used, it would allow for asynchronous programming and potentially affect the performance results.

**Other alternatives**

If you want to explore alternative approaches, here are a few options:

* Using a different data structure (e.g., using a `Set` or an array with indices)
* Implementing a custom solution using only basic JavaScript constructs
* Utilizing Web Workers for parallel processing

Keep in mind that these alternatives may introduce additional complexity and may not be suitable for all use cases.

Now, you have a better understanding of the approaches tested on MeasureThat.net. Feel free to ask if you have any further questions or need more clarification!

Related benchmarks:

find duplicates (version: 10)

solutions to finding duplicates in array

Comparing performance of: map filter vs reduce vs lodash

Created: 6 years ago by: Registered User

Jump to the latest result

map filter

reduce

lodash

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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