Benchmark: Add 10 elements to an Array where each element includes one array

Tests:

1️⃣ Array.from()
const arr = Array.from({ length: 10 }, () => []);
2️⃣ Array() and fill()
const arr2 = Array(10).fill([]);
3️⃣ for loop
const arr3 = []; for (let i = 0; i < 10; i += 1) { arr3.push([]); }
4️⃣ while loop
const arr4 = []; let i = 0; while (i < 10) { arr4.push([]); i += 1; }
5️⃣ do while loop
const arr5 = []; let j = 0; do { arr5.push([]); j += 1; } while (j < 10);
6️⃣ for of loop
const arr6 = []; for (const _ of Array(10)) { arr6.push([]); }
7️⃣ ... spread operator, Array() and map()
const arr7 = [...Array(10)].map(() => []);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1️⃣ Array.from()
2️⃣ Array() and fill()
3️⃣ for loop
4️⃣ while loop
5️⃣ do while loop
6️⃣ for of loop
7️⃣ ... spread operator, Array() and map()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 106 on Mac OS X 10.14.3

View result in a separate tab

Test name	Executions per second
1️⃣ Array.from()	501908.6 Ops/sec
2️⃣ Array() and fill()	1899939.9 Ops/sec
3️⃣ for loop	11281262.0 Ops/sec
4️⃣ while loop	11851864.0 Ops/sec
5️⃣ do while loop	11128064.0 Ops/sec
6️⃣ for of loop	2606430.5 Ops/sec
7️⃣ ... spread operator, Array() and map()	2181438.2 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark json and explain what's being tested.

**Benchmark Overview**

The benchmark is designed to measure the performance of creating an array with multiple sub-arrays using different approaches. The test creates an empty array, then pushes multiple empty arrays into it, similar to how one would create a nested array in JavaScript.

**Approaches Compared**

1. **Array.from()**: This method creates a new array from an iterable object, such as an array literal or string.
2. **Array() and fill()**: This approach uses the `Array` constructor to create an empty array, then fills it with a specified value (in this case, an empty array) using the `fill()` method.
3. **For loop**: This approach uses a traditional for loop to push multiple empty arrays into the main array.
4. **While loop**: Similar to the for loop, but uses a while loop instead.
5. **Do-while loop**: Another type of loop that pushes multiple empty arrays into the main array.
6. **For of loop**: This approach uses a for...of loop to iterate over an array and push elements (in this case, empty arrays) into the main array.
7. **Spread operator, Array() and map()**: This approach uses the spread operator (`...`) to create a new array from an existing one, then maps over it to create multiple sub-arrays.

**Pros and Cons of Each Approach**

Here's a brief summary:

* **Array.from()**: Pros: concise and efficient. Cons: may not be supported in older browsers.
* **Array() and fill()**: Pros: widely supported. Cons: can be slower due to the need to call `fill()` method multiple times.
* **For loop**: Pros: familiar syntax. Cons: can be less efficient than other approaches.
* **While loop**: Similar pros and cons as the for loop.
* **Do-while loop**: Similar pros and cons as the for loop.
* **For of loop**: Pros: concise and modern syntax. Cons: may not be supported in older browsers or environments.
* **Spread operator, Array() and map()**: Pros: efficient and concise. Cons: may not be supported in older browsers or environments.

**Library Used**

None, as all the approaches rely on built-in JavaScript features.

**Special JS Features or Syntax**

No special features or syntax are used in this benchmark.

**Alternatives**

Other alternatives for creating nested arrays include using `Array.prototype.push()` and `Array.prototype.concat()`, or using a library like Lodash's `repeat()` function. However, the approaches tested here provide a good starting point for measuring performance differences between various methods of creating nested arrays in JavaScript.

It's worth noting that this benchmark is likely intended to measure the performance of different JavaScript engines and browsers when dealing with complex array operations. By using a variety of approaches, the test ensures that the results are representative of different scenarios and can be used to compare the performance of different engines and browsers.

Related benchmarks:

Add 10 elements to an Array where each element includes one array (version: 0)

Comparing performance of: 1️⃣ Array.from() vs 2️⃣ Array() and fill() vs 3️⃣ for loop vs 4️⃣ while loop vs 5️⃣ do while loop vs 6️⃣ for of loop vs 7️⃣ ... spread operator, Array() and map()

Created: 2 years ago by: Guest

Jump to the latest result

1️⃣ Array.from()

2️⃣ Array() and fill()

3️⃣ for loop

4️⃣ while loop

5️⃣ do while loop

6️⃣ for of loop

7️⃣ ... spread operator, Array() and map()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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