Benchmark: flatmap - MeasureThat.net

Script Preparation code:

var a = new Map();
for (let i=0;i<1000;i++) {
	a.set('x'+i, {p:['a', 'b', 'c']});
}

Tests:

Array from with map + flat
const res = Array.from(a.values(), (val) => val.p).flat();
Array push + flat
const b = []; for (let v of a.values()) { b.push(v.p); } const res = b.flat();
spread
let res = []; for (let v of a.values()) { res = [...res, ...v.p]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array from with map + flat
Array push + flat
spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36

Browser/OS: Chrome 102 on Windows

View result in a separate tab

Test name	Executions per second
Array from with map + flat	925.7 Ops/sec
Array push + flat	995.5 Ops/sec
spread	306.3 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 measures the performance of three different approaches to flatten an array of arrays in JavaScript: `Array.from()`, `push()` + `flat()`, and spread operator (`...`).

**Benchmark Definition JSON Analysis**

The benchmark definition JSON contains the following information:

* **Name**: The name of the benchmark, which is "flatmap".
* **Description**: An empty string, indicating that no description is provided for this benchmark.
* **Script Preparation Code**: A JavaScript script that creates a map `a` with 1000 entries, where each entry has an array `p` containing three elements. This script is used to prepare the data for the benchmark.
* **Html Preparation Code**: An empty string, indicating that no HTML preparation code is required.

**Individual Test Cases**

The individual test cases are defined as an array of objects, each containing:

* **Benchmark Definition**: A JavaScript string that represents a specific test case. Each string defines how to flatten the array `a` using one of the three approaches.
* **Test Name**: A human-readable name for each test case.

**Breakdown of Test Cases**

Here's a brief explanation of each test case:

1. **Array from with map + flat**: This test case uses `Array.from()` and `flat()` to flatten the array `a`.
2. **Array push + flat**: This test case uses the `push()` method to add elements to an array and then calls `flat()` on that array.
3. **spread**: This test case uses the spread operator (`...`) to flatten the array `a`.

**Library Used**

In this benchmark, no libraries are explicitly used.

**Special JS Features or Syntax**

The benchmark uses the following special JavaScript features:

* `Array.from()`: A method introduced in ECMAScript 2015 (ES6) that creates a new array from an iterable.
* Spread operator (`...`): Introduced in ECMAScript 2015 (ES6), this operator is used to expand an array into individual elements.

**Pros and Cons of Each Approach**

Here's a brief pros and cons analysis for each approach:

1. **Array.from() + flat()**:
	* Pros: Fast, efficient, and widely supported.
	* Cons: May have performance issues with very large arrays due to the creation of an intermediate array.
2. **push() + flat()**:
	* Pros: Works well with existing code that uses `push()` and can be optimized for small arrays.
	* Cons: May be slower than `Array.from()` + `flat()` for larger arrays, as it involves multiple allocations and copies.
3. **Spread operator (`...`)**:
	* Pros: Simple, efficient, and widely supported across modern browsers.
	* Cons: May not work well with older browsers or environments that don't support ES6 features.

**Other Alternatives**

If the spread operator is not an option due to browser limitations or other constraints, some alternative approaches can be used:

1. **Reduce()**: A method introduced in ECMAScript 5 (ES5) that can be used to flatten arrays by reducing them with a callback function.
2. **map() + concat()**: This approach involves using `map()` to create a new array and then concatenating the results using `concat()`.

However, these alternatives may have different performance characteristics and are generally less efficient than the spread operator or `Array.from()` + `flat()`.

Related benchmarks:

flatmap (version: 4)

Comparing performance of: Array from with map + flat vs Array push + flat vs spread

Created: 2 years ago by: Registered User

Jump to the latest result

Array from with map + flat

Array push + flat

spread

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