Benchmark: Custom flatten function VS Array.prototype.flat

Script Preparation code:

function flatten(arr) {
	let i = 0;
	const len = arr.length;
	const result = [];
	let item;

	while (i < len) {
		item = Array.isArray(arr[i]) ? flatten(arr[i]) : [arr[i]];
		[].push.apply(result, item);
		i += 1;
	}

	return result;
}

Tests:

Custom Flatten Function
var params = [ "hello", true, 7 ]; var other = flatten([1, 2, params]);
Array.prototype.flat
var params = [ "hello", true, 7 ]; var other = [1, 2, params].flat()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Custom Flatten Function
Array.prototype.flat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Linux

View result in a separate tab

Test name	Executions per second
Custom Flatten Function	849704.4 Ops/sec
Array.prototype.flat	1040658.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark, `Custom flatten function VS Array.prototype.flat`, compares the performance of two approaches for flattening arrays in JavaScript: a custom implementation using a recursive function (`flatten`) and the built-in `Array.prototype.flat()` method.

**Tested Options**

Two options are compared:

1. **Custom Flatten Function**: A hand-written, recursive function named `flatten` that takes an array as input and returns a flattened array.
2. **Array.prototype.flat()**: The built-in method of the Array prototype that flattens arrays in place.

**Pros and Cons of Each Approach**

**Custom Flatten Function:**

Pros:

* Can be optimized for specific use cases or performance requirements
* Might provide more control over the flattening process

Cons:

* Requires manual implementation, which can lead to errors and bugs
* May not be as efficient or scalable as built-in methods

**Array.prototype.flat():**

Pros:

* Built-in method with optimized performance and scalability
* Easy to use and requires minimal code

Cons:

* Less control over the flattening process compared to a custom implementation
* Might have limitations or quirks due to its internal implementation

**Library Considerations**

In the provided benchmark, there is no explicit mention of any external libraries. However, it's essential to note that both options rely on built-in JavaScript features: `Array.prototype.flat()` uses the ECMAScript 2019 (ES2019) standard for array flattening, while the custom implementation may use older JavaScript versions or workarounds.

**Special JS Features**

The benchmark uses ES2019's `flat()` method, which is a relatively recent feature. The custom implementation might not be compatible with older browsers or environments that don't support this feature. If you need to support older browsers, consider using a polyfill or adapting the custom implementation for compatibility.

**Other Alternatives**

If you're looking for alternative approaches, here are a few options:

1. **Array.prototype.reduce()**: You can use `reduce()` to flatten arrays, although it might be less efficient than `flat()` due to its overhead.
2. **Array.prototype.forEach()**: Another option is to use `forEach()` in conjunction with `Array.prototype.push()`, but this approach can lead to performance issues and is generally not recommended.
3. **Third-party libraries**: Depending on your specific requirements, you might consider using a library like Lodash or Ramda for array manipulation.

In conclusion, the benchmark provides a straightforward comparison of two approaches for flattening arrays in JavaScript. The custom implementation requires manual effort but offers more control over the process, while `Array.prototype.flat()` is built-in and optimized for performance.

Related benchmarks:

Custom flatten function VS Array.prototype.flat (version: 0)

Compare a custom flatten function with Array.prototype.flat

Comparing performance of: Custom Flatten Function vs Array.prototype.flat

Created: 4 years ago by: Guest

Jump to the latest result

Custom Flatten Function

Array.prototype.flat

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