Benchmark: lodash flatMapDeep vs reduce

HTML Preparation code:

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

Script Preparation code:

window.obj = {};

for (var i = 0, len = 10; i < len; i++) {
  var arr = []
  obj['key' + i] = arr
  for (var n = 0, len = 10; n < len; n++) {
    arr.push({ ['key' + n]: n });
  }
}

Tests:

flatten
_.flatMapDeep(obj, (acc, val, key) => { acc[key] = val.map(d => ({ label: key, value: val })); return acc; }, {})
reduce
Object.entries(obj).reduce((acc, [key, val]) => { acc[key] = val.map(d => ({ label: key, value: val })); return acc; }, {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
flatten
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 months ago)

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

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
flatten	0.0 Ops/sec
reduce	1589750.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark measures the performance of two different approaches to flatten an object in JavaScript: `lodash flatMapDeep` and `reduce`.

**Options Compared**

There are two options compared:

1. **Lodash `flatMapDeep`**: A function from the Lodash library that flattens an object by recursively iterating over its properties and returning a new array with transformed values.
2. **Array `reduce` method**: The built-in `reduce()` method of arrays in JavaScript, which applies a callback function to each element in the array and returns a single value.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Lodash `flatMapDeep`**:
	+ Pros:
		- Easier to read and understand for developers familiar with Lodash.
		- Can handle nested arrays and objects more efficiently than `reduce`.
	+ Cons:
		- Requires including the Lodash library, which may add extra overhead.
		- May have a higher memory footprint due to the creation of intermediate arrays.
* **Array `reduce` method**:
	+ Pros:
		- Native JavaScript implementation, so no additional libraries are required.
		- Can be more efficient in terms of memory usage and performance.
	+ Cons:
		- Requires more manual understanding of the callback function's parameters (acc, val, key).
		- May not handle nested arrays and objects as efficiently as `flatMapDeep`.

**Library: Lodash**

Lodash is a popular JavaScript library that provides various utility functions for tasks such as array manipulation, object transformation, and more. In this benchmark, `flatMapDeep` is used to flatten an object by recursively iterating over its properties.

**Special JS Feature/Syntax**

There isn't any special JavaScript feature or syntax being used in the benchmark, apart from using the `reduce()` method which is a standard JavaScript API.

**Alternative Approaches**

If you want to implement your own flattening logic without relying on libraries like Lodash, here are some alternative approaches:

1. **Recursive Function**: You can write a recursive function that manually iterates over the object's properties and creates an array with transformed values.
2. **Iterative Approach**: Use a loop to iterate over the object's properties and create an array with transformed values.
3. **Using `for...in` Loop**: Use a `for...in` loop to iterate over the object's properties and create an array with transformed values.

Keep in mind that these approaches may not be as efficient or elegant as using libraries like Lodash, but they can provide insight into how flattening logic works at a low level.

Related benchmarks:

lodash flatMapDeep vs reduce (version: 0)

Comparing performance of: flatten vs reduce

Created: 9 months ago by: Registered User

Jump to the latest result

flatten

reduce

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