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

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
unique by map, extract with deconstruct	4199.2 Ops/sec
obj UniqueBy, extract with for...in loop	461.1 Ops/sec
obj UniqueBy, extract with Object.values()	477.9 Ops/sec
unique by map, extract with ArrayFrom	3352.9 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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:

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: 4 years ago by: Registered User

Jump to the latest 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

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