Benchmark: Uniq by vs Array

HTML Preparation code:

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

Tests:

UniqBy
const a = [{a:1},{a:1},{a:1},{a:2},{a:2},{a:3}] const uniques = _.uniqBy(a, 'a')
Set
const a = [{a:1},{a:1},{a:1},{a:2},{a:2},{a:3}] const uniques = []; const set = []; for (const e of a) { if(set.indexOf(e.a) === -1) { uniques.push(e); set.push(e.a); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
UniqBy
Set

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 Benchmark Definition and explain what is being tested.

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks, which means comparing the performance of different approaches or methods in various JavaScript contexts.

The provided JSON represents a benchmark with two test cases: "Uniq by vs Array" and its individual test case "Set".

**What is being tested?**

The main objective of this benchmark is to compare the performance of two approaches for removing duplicates from an array:

1. **`_.uniqBy(a, 'a')`**: This approach uses the Lodash library's `uniqBy` function, which removes duplicate elements from an array based on a specified property (`'a'` in this case).
2. **Manual implementation using a set**: The second test case implements a simple algorithm to remove duplicates by iterating through the array and adding elements to a set (using `set.indexOf(e.a) === -1`) if they are not already present.

**Options compared**

The benchmark compares two different approaches:

* Lodash's `uniqBy` function
* A manual implementation using a set

**Pros and Cons of each approach:**

**Lodash's `uniqBy` function:**
	+ Pros:
		- Provides a simple and efficient way to remove duplicates.
		- Handles edge cases (e.g., empty arrays, null values) automatically.
	+ Cons:
		- Requires an external library (Lodash).
		- May not be the most educational example for learning about JavaScript fundamentals.

**Manual implementation using a set:**
	+ Pros:
		- Teaches developers about JavaScript fundamental concepts, such as iteration and set operations.
		- Can be more efficient if implemented correctly.
	+ Cons:
		- Requires manual effort to implement and debug.
		- May not handle edge cases as elegantly as Lodash's implementation.

**Other considerations:**

* The benchmark uses a small test array with 6 elements, which might not be representative of larger datasets. Scaling the test to larger arrays would provide more accurate results.
* It is worth noting that JavaScript engines can introduce additional overhead due to garbage collection or other factors, which may impact performance differences between these approaches.

**Library used:**

Lodash (version 4.17.5) provides a `uniqBy` function for removing duplicate elements from an array based on a specified property.

**Special JS feature or syntax:**

None mentioned in this benchmark, but it's worth noting that MeasureThat.net often uses advanced JavaScript features and syntax to make benchmarks more interesting and challenging.

Related benchmarks:

Uniq by vs Array (version: 0)

Comparing performance of: UniqBy vs Set

Created: 3 years ago by: Guest

Jump to the latest result

UniqBy

Set

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