Benchmark: Lodash Flatten vs Array.flat() with infinite

HTML Preparation code:

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

Tests:

array flat with infinite
const arrayA = ['hi', 'hi', ['hi', 'hi', ['hi', ['hi']]]]; const arrayB = ['hi', 'hi', 'hi', 'hi', ['hi', 'hi', ['hi', ['hi', ['hi', 'hi', ['hi', ['hi']]]]]]]; const flattened = [ arrayA, arrayB ].flat(Infinity); console.log(flattened);
lodash flatten
const arrayA = ['hi', 'hi', ['hi', 'hi', ['hi', ['hi']]]]; const arrayB = ['hi', 'hi', 'hi', 'hi', ['hi', 'hi', ['hi', ['hi', ['hi', 'hi', ['hi', ['hi']]]]]]]; const flattened = _.flatten([arrayA, arrayB]); console.log(flattened);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array flat with infinite
lodash flatten

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Test name	Executions per second
array flat with infinite	204550.1 Ops/sec
lodash flatten	220481.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in these JavaScript microbenchmarks.

**Overview**

The tests compare the performance of two approaches to flatten an array: using `Array.flat()` with an infinite depth and using the `flatten()` function from the Lodash library.

**Options Compared**

1. **Array.flat() with Infinite Depth**: This method uses the `flat()` function to recursively flatten the array, allowing a specified depth (in this case, infinite) to be passed as an argument.
2. **Lodash.flatten()**: This method is part of the Lodash utility library and provides a convenient way to flatten arrays.

**Pros and Cons**

* **Array.flat() with Infinite Depth**:
	+ Pros: Simple, built-in JavaScript function, can handle nested arrays of arbitrary depth.
	+ Cons: May be less efficient than other approaches due to its recursive nature.
* **Lodash.flatten()**:
	+ Pros: Convenient, readable syntax, often faster than manual implementation due to Lodash's optimized codebase.
	+ Cons: Requires including the Lodash library in the test, which may add overhead.

**Library Used**

The `flatten()` function from the Lodash library is used in one of the benchmark definitions. Lodash is a popular utility library for JavaScript that provides a wide range of functions to make common tasks easier.

**Special JS Features or Syntax**

None are mentioned in these specific benchmark definitions, but it's worth noting that some modern browsers and Node.js versions support the `flatMap()` method on arrays, which may be used as an alternative approach for flattening arrays.

**Other Alternatives**

Some other approaches to flatten arrays include:

* Using a recursive function with manual iteration.
* Using the `Array.prototype.reduce()` method.
* Using the `Array.prototype.map()` and `Array.prototype.concat()` methods in combination.

For example, using a recursive function would look like this:
```javascript
function flatten(arr, depth = 1) {
  if (depth === 0 || !Array.isArray(arr)) return arr;
  const result = [];
  for (const item of arr) {
    result.push(...flatten(item, depth - 1));
  }
  return result;
}
```
This approach can be more readable and maintainable than using `flat()` or `flatten()`, but may have performance overhead due to the manual iteration.

Related benchmarks:

Lodash Flatten vs Array.flat() with infinite (version: 0)

lodash flatten vs spread

Comparing performance of: array flat with infinite vs lodash flatten

Created: 2 years ago by: Guest

Jump to the latest result

array flat with infinite

lodash flatten

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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