Benchmark: Fixed: Performance of uniqueBy using new Map or reducing to an object, also comparing for..in and Object.values for extracting values - More3

Fixed: Performance of uniqueBy using new Map or reducing to an object, also comparing for..in and Object.values for extracting values - More3 (version: 4)

Compare performance between the native Object.values(obj) function vs the lodash _.values() option and a function that extracts the values of an object using a for...in loop.

Comparing performance of: unique by map, extract with deconstruct vs obj UniqueBy, extract with for...in loop vs obj UniqueBy, extract with Object.values() vs unique by map, extract with ArrayFrom

Created: 5 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function uniqueBy(list, predicate, extractor) {
 	const a = new Map(list.map(l => [predicate(l), l]))
    return extractor(a)
}

function extractorDeconstruct(iterator) {
	return [...iterator.values()]
}

function extractorArrayFrom(iterator) {
 	return Array.from(iterator) 
}

function objUniqueBy(list, predicate, extractor) {
    const a = list.reduce((acc, val) => Object.assign(acc, { [predicate(val)]: val }), {})
    return extractor(a)
}

function extractValuesForIn(obj) {
   const t = [];
   for(var key in obj) { t.push(obj[key]); }
   return t;
}

function extractValuesObject(obj) {
  return Object.values(obj);
}

function makeRange(n) {
  let range = []
  for (let i = 0; i < n; i++) {
    range.push(i)
  }
  return range
}

Tests:

unique by map, extract with deconstruct
const a = Object.assign(makeRange(3000).map(i => ({ a: i, b: 1})), makeRange(1000).map(i => ({ a: i, b: 2}))) uniqueBy(a, (x) => x['a'], extractorDeconstruct)
obj UniqueBy, extract with for...in loop
const a = Object.assign(makeRange(3000).map(i => ({ a: i, b: 1})), makeRange(1000).map(i => ({ a: i, b: 2}))) objUniqueBy(a, (x) => x['a'], extractValuesForIn);
obj UniqueBy, extract with Object.values()
const a = Object.assign(makeRange(3000).map(i => ({ a: i, b: 1})), makeRange(1000).map(i => ({ a: i, b: 2}))) objUniqueBy(a, (x) => x['a'], extractValuesObject);
unique by map, extract with ArrayFrom
const a = Object.assign(makeRange(3000).map(i => ({ a: i, b: 1})), makeRange(1000).map(i => ({ a: i, b: 2}))) uniqueBy(a, (x) => x['a'], extractorArrayFrom)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
unique by map, extract with deconstruct
obj UniqueBy, extract with for...in loop
obj UniqueBy, extract with Object.values()
unique by map, extract with ArrayFrom

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.

I'll break down the benchmark and explain what's being tested, compared options, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark compares the performance of four different approaches to extract unique values from an object:

1. `uniqueBy` using `new Map` or reducing to an object
2. `objUniqueBy` with `for...in` loop
3. `objUniqueBy` with `Object.values()`
4. `uniqueBy` with `Array.from()` (replaced with `extractorArrayFrom` in the benchmark)

**What's being tested**

The benchmark tests the performance of each approach on a specific input: an array of 3000 objects, each containing two properties (`a` and `b`). The goal is to extract unique values from the object using one of the four approaches.

**Options compared**

Here are the options being compared:

1. **uniqueBy** (using `new Map` or reducing to an object): This approach uses a `Map` data structure to store unique values and then applies a transformer function to extract the values.
2. **objUniqueBy** with `for...in` loop: This approach iterates over the object's properties using `for...in` loop, checks each property for uniqueness, and returns an array of unique values.
3. **objUniqueBy** with `Object.values()`: Similar to the previous option, but uses `Object.values()` to extract the unique values.
4. **uniqueBy** with `Array.from()**: This approach uses `Array.from()` to transform the map into an array of unique values.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **uniqueBy** (using `new Map` or reducing to an object):
	* Pros: Efficient use of memory, fast lookup times.
	* Cons: Can be slower due to map creation and iterator usage.
2. **objUniqueBy** with `for...in` loop:
	* Pros: Simple, easy to understand.
	* Cons: Slow due to multiple loop iterations and property checks.
3. **objUniqueBy** with `Object.values()`: Similar pros and cons as the previous option, but with the added benefit of using a built-in function.
4. **uniqueBy** with `Array.from()`:
	* Pros: Fast transformation into an array, similar to the previous options.
	* Cons: Can be slower due to additional iterator usage.

**Other considerations**

* The benchmark uses a fixed-size input (3000 objects) and a simple object structure, which may not reflect real-world scenarios.
* The `uniqueBy` implementation using `new Map` or reducing to an object is likely the most efficient approach for large datasets.
* The `objUniqueBy` with `for...in` loop option may be less efficient due to its slow iteration and property checking.

**Alternative approaches**

Other possible approaches to extract unique values from an object could include:

1. Using a library like Lodash or Underscore.js, which provide optimized implementations for this task.
2. Using a different data structure, such as a `Set`, which would eliminate the need for manual uniqueness checks.
3. Optimizing the input data structure, such as using a compact representation of the objects.

Overall, the benchmark provides a good starting point to compare the performance of different approaches to extract unique values from an object. However, it's essential to consider real-world scenarios and optimize the approach accordingly.

Related benchmarks: