Benchmark: Test concat vs flatter in loop etc

HTML Preparation code:

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

Script Preparation code:

var arr = [];
for (var i = 0; i < 10000; i++) {
	arr.push(() => [i]);
};

Tests:

Map
let nodesFoundByClassName = _.flatten(_.map(arr, (el) => el()));
Concat
let nodesFoundByClassName = []; for (let i = 0, len = arr.length; i < len; i++) nodesFoundByClassName = nodesFoundByClassName.concat(arr[i]());
Chain
let nodesFoundByClassName = _.chain(arr).map(arr, (el) => el()).flatten().value();
Push with end flatten
let nodesFoundByClassName = []; for (let i = 0, len = arr.length; i < len; i++) nodesFoundByClassName.push(arr[i]()); nodesFoundByClassName = _.flatten(nodesFoundByClassName);
Index assign with end flatten
var i = -1; var length = arr.length; var nodesFoundByClassName = Array(length); while (++i < length) { nodesFoundByClassName[i] = arr[i](); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map
Concat
Chain
Push with end flatten
Index assign with end flatten

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its options.

**Benchmark Definition**

The benchmark is designed to compare different approaches for flattening an array of functions in JavaScript. The array, `arr`, contains 10,000 elements, each representing a function that returns an array.

**Options Compared**

1. **Map**: This approach uses the `map()` method to apply each function in the array to an empty array and then flattens the resulting array using `_flatten()`.
2. **Concat**: This approach uses the `concat()` method to concatenate the results of applying each function to an empty array.
3. **Chain**: This approach uses a chain of methods from Lodash (`_chain()`, `map()`, `flatten()`) to flatten the array.
4. **Push with end flatten**: This approach uses `push()` to add each function's result to an array and then flattens the resulting array using `_flatten()`.
5. **Index assign with end flatten**: This approach uses indexing (`arr[i]`) to access each function in the array and then flattens the resulting array using `_flatten()`.

**Pros and Cons of Each Approach**

1. **Map**:
	* Pros: Efficient use of `map()` for applying functions, easy to read.
	* Cons: May have performance issues due to the extra step of flattening the array.
2. **Concat**:
	* Pros: Simple and straightforward approach.
	* Cons: May be slower than other approaches due to the need to concatenate arrays.
3. **Chain**:
	* Pros: Uses a chain of methods from Lodash, which can be efficient for flattening arrays.
	* Cons: Requires importing an external library (Lodash).
4. **Push with end flatten**:
	* Pros: Simple and straightforward approach.
	* Cons: May require more memory due to the need to store all elements in an array before flattening.
5. **Index assign with end flatten**:
	* Pros: Efficient use of indexing for accessing functions, easy to read.
	* Cons: May not be as straightforward as other approaches.

**Library and Syntax**

The benchmark uses Lodash (version 3.10.1) for its `chain()`, `map()`, and `_flatten()` methods. The syntax is a mix of JavaScript's built-in methods (`map()`, `concat()`) and the chainable methods from Lodash (`_chain()`, `map()`, `flatten()`).

**Other Considerations**

* **Performance**: The benchmark measures executions per second, which provides an indication of performance.
* **Memory Usage**: Some approaches (e.g., `Push with end flatten`) may require more memory due to the need to store all elements in an array before flattening.

**Alternatives**

If you don't want to use Lodash or other external libraries, you can also consider:

1. Using native JavaScript methods (e.g., `map()`, `concat()`) without any additional libraries.
2. Implementing your own flattening algorithm using a loop and indexing.
3. Using a different library that provides similar functionality (e.g., `lodash-es` or `ramda`).

Latest run results:

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

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

Browser/OS: Chrome 68 on Mac OS X 10.13.6

View result in a separate tab

Test name	Executions per second
Map	2299.2 Ops/sec
Concat	16.0 Ops/sec
Chain	215.4 Ops/sec
Push with end flatten	813.0 Ops/sec
Index assign with end flatten	1072.9 Ops/sec

Related benchmarks:

Test concat vs flatter in loop etc (version: 0)

Comparing performance of: Map vs Concat vs Chain vs Push with end flatten vs Index assign with end flatten

Created: 7 years ago by: Guest

Jump to the latest result

Map

Concat

Chain

Push with end flatten

Index assign with end flatten

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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