Benchmark: flatten2 - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

flattenArray = arr => {
	return arr.reduce( (result, el) => {
		return result.concat(
			Array.isArray(el) ? flattenArray(el) : el
		)
	}, []);
}

function baseFlatten(array, result) {
	var index = -1,
		length = array.length;

	result || (result = []);

	while (++index < length) {
		var value = array[index];
		if (Array.isArray(value)) {
			baseFlatten(value,  result);

		} else {
			result[result.length] = value;
		}
	}
	return result;
}

function flattenDeep(array) {
	var length = array == null ? 0 : array.length;
	return length ? baseFlatten(array) : [];
}

Tests:

first elegant
flattenArray([ 1, [ 2, [ 3 ] ], 4 ])
second better
flattenDeep([ 1, [ 2, [ 3 ] ], 4 ])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
first elegant
second better

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and explain what's being tested, compared, and their pros/cons.

**Benchmark Definition**

The test cases are designed to measure the performance of two different functions:

1. `flattenArray`: A custom function that flattens an array by recursively calling itself on nested arrays.
2. `baseFlatten` and `flattenDeep`: Two built-in JavaScript functions provided by the Lodash library, which are used as alternatives to `flattenArray`.

**Options being compared**

The two options being compared are:

A) Custom implementation (`flattenArray`)
B) Built-in JavaScript function (`baseFlatten`) from Lodash library
C) Another alternative implemented using a different approach (`flattenDeep`)

**Pros and Cons of each option**

1. **Custom implementation (`flattenArray`)**:
	* Pros: Customization, potential performance optimization through loop optimizations or caching.
	* Cons: More complex code, may not be optimized for performance, requires additional testing to ensure correctness.
2. **Built-in JavaScript function (`baseFlatten`) from Lodash library**:
	* Pros: Optimized for performance by the Lodash team, widely tested and validated, easy to use.
	* Cons: May have dependencies on other Lodash functions or modules, may not be suitable for very deep arrays due to optimization trade-offs.
3. **Alternative implementation (`flattenDeep`)**:
	* Pros: Potential performance optimizations through different algorithmic approaches, easier to understand than a complex recursive function.
	* Cons: May require additional testing and validation, may have dependencies on other libraries or modules.

**Library used**

The test uses the Lodash library, which provides a `baseFlatten` function that can be used as an alternative to the custom implementation. The `flattenDeep` function is also provided by Lodash, but its performance optimizations might not be suitable for all use cases.

**Special JS feature or syntax**

None mentioned in the benchmark definition, but note that JavaScript features like async/await, destructuring, and rest parameters are commonly used in modern JavaScript codebases. However, they are not explicitly mentioned in this benchmark definition.

**Other alternatives**

There might be other libraries or modules available that provide similar functionality to Lodash, such as:

* `Array.prototype.flat()` (ES6+): A built-in function that flattens arrays.
* `lodash-es` (Lodash library for ES module): An alternative implementation of the Lodash library in an ES module format.

Keep in mind that this benchmark definition is designed to compare performance between different approaches, so additional alternatives might not be considered if they have similar performance characteristics.

Latest run results:

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

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

Browser/OS: Chrome 79 on Mac OS X 10.15.1

View result in a separate tab

Test name	Executions per second
first elegant	294313.6 Ops/sec
second better	988855.4 Ops/sec

Related benchmarks:

flatten2 (version: 0)

Comparing performance of: first elegant vs second better

Created: 4 years ago by: Guest

Jump to the latest result

first elegant

second better

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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