Benchmark: flattendeep - 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:

niceFlattenDeep = arr => {
	return arr.reduce( (result, el) => {
		return result.concat(
			Array.isArray(el) ? niceFlattenDeep(el) : el
		)
	}, []);
}



fasterFlattenDeep = (array, result) => {
	const length = array.length;
	let index = -1;

	result = result || [];

	while (++index < length) {
		let value = array[index];
		if (Array.isArray(value)) {
			fasterFlattenDeep(value,  result);

		} else {
			result[result.length] = value;

		}
	}
	
	return result;
}

Tests:

niceFlattenDeep
niceFlattenDeep([ 1, [ 2, [ 3 ] ], 4, [[5, [6, 7]],[[[[[8]]]]]] ])
fasterFlattenDeep
fasterFlattenDeep([ 1, [ 2, [ 3 ] ], 4, [[5, [6, 7]],[[[[[8]]]]]] ])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
niceFlattenDeep
fasterFlattenDeep

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents two JavaScript microbenchmarks, `flattendeep` and `fasterFlattenDeep`, which test the performance of flattening nested arrays in JavaScript.

**Script Definitions**

1. **niceFlattenDeep**:

```javascript
function niceFlattenDeep(arr) {
    return arr.reduce((result, el) => {
        return result.concat(
            Array.isArray(el) ? niceFlattenDeep(el) : el
        );
    }, []);
}
```

This function uses the `Array.prototype.reduce()` method to iterate over each element in the input array. If an element is an array itself, it recursively calls `niceFlattenDeep()` on that element and concatenates the result with the initial array.

**Pros:**

- Easy to understand and implement.
   - Uses a standard JavaScript method (`Array.prototype.reduce()`) to solve the problem.

**Cons:**

- Can be slow due to recursive function calls, especially for deeply nested arrays.
   - May lead to stack overflow errors if the input array is too large.

2. **fasterFlattenDeep**:

```javascript
function fasterFlattenDeep(array, result) {
    const length = array.length;
    let index = 0;

while (++index < length) {
        let value = array[index];
        if (Array.isArray(value)) {
            fasterFlattenDeep(value, result);
        } else {
            result[result.length] = value;
        }
    }

return result;
}
```

This function uses a simple loop to iterate over each element in the input array. If an element is an array itself, it recursively calls `fasterFlattenDeep()` on that element.

**Pros:**

- Less prone to stack overflow errors compared to `niceFlattenDeep()`.
   - May be faster due to fewer function calls and iterations.

**Cons:**

- Requires explicit initialization of the result array.
   - May not be as readable or maintainable as `niceFlattenDeep()`.

**Library Used: Lodash.js**

The `Html Preparation Code` includes a link to Lodash.js, which is a popular utility library for JavaScript. In this case, it's used to provide the `Array.isArray()` function, which is not part of the standard JavaScript API.

**Special JS Feature or Syntax**

There are no special features or syntaxes used in these benchmarks beyond standard JavaScript methods and libraries.

**Alternatives**

Other approaches to flatten nested arrays could include:

1. **Using `Flat()` method (ES2019+):**

```javascript
function flattenDeep(arr) {
    return arr.flat(Infinity);
}
```

This approach is more concise and efficient but may not be supported in older browsers.

2. **Using a library like underscore.js or Ramda:**

These libraries provide alternative implementations for flattening arrays, which might offer better performance or readability depending on the specific use case.

3. **Iterating manually without recursion or using `Flat()` method:**

This approach would involve manually iterating over each element in the array and concatenating the result, similar to `fasterFlattenDeep()`. However, it may not be as efficient or readable due to its lack of standard JavaScript methods.

Related benchmarks:

flattendeep (version: 0)

Comparing performance of: niceFlattenDeep vs fasterFlattenDeep

Created: 6 years ago by: Guest

Jump to the latest result

niceFlattenDeep

fasterFlattenDeep

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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