Benchmark: Push vs Create Fill and Map vs Create with Array.From

Script Preparation code:

var count = 100000;
var result = [];

Tests:

Push
for (let i = 0; i < count; i++) { result.push(`variable_${i}`) }
Create Array, fill and map
result = Array(count).fill(0).map((_, i) => `variable_${i}`)
Create with Array.from
result = Array.from({length: count}, (_, i) => `variable_${i}`)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Push
Create Array, fill and map
Create with Array.from

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.

Let's break down the benchmark and its test cases.

**Benchmark Purpose:**
The purpose of this benchmark is to compare three different approaches for creating an array of strings in JavaScript:

1. `push` method
2. `Array.from()` with a callback function
3. `Array.fill()` followed by `map()`

These approaches are used to generate an array of 100,000 variable names (e.g., `variable_0`, `variable_1`, etc.).

**Options Compared:**

* **Push Method**: Uses the `push` method to add elements to the end of the array.
* **Create Array, fill and map**: Creates an empty array using `Array(count)`, fills it with zeros using `fill(0)`, and then maps a string function over the array using `map((_, i) => `variable_${i}`)`.
* **Create with Array.from**: Creates an array from an object with a length of `count` using `Array.from({length: count})`, and then uses a callback function to generate the variable names.

**Pros and Cons of Each Approach:**

1. **Push Method**:
	* Pros:
		+ Easy to implement
		+ Fast access to elements at any position in the array
	* Cons:
		+ Requires multiple operations (push, get element), which can be slower than a single operation for all elements
2. **Create Array, fill and map**:
	* Pros:
		+ Fast creation of an empty array
		+ Fast mapping over the array using `map()`
	* Cons:
		+ Requires two separate operations (filling with zeros, mapping), which can be slower than a single operation for all elements
3. **Create with Array.from**:
	* Pros:
		+ Creates an array from an object, which can be faster than creating an empty array using `Array()`
		+ Fast mapping over the array using `map()`
	* Cons:
		+ Requires a callback function to generate the variable names, which can add overhead

**Library Used:**
None. This benchmark does not use any external libraries.

**Special JavaScript Features/Syntax:**
The test cases use the following features:

1. **Arrow Functions**: Used in `Array.from()` with a callback function.
2. **Template Literals**: Used to generate variable names using template literals (e.g., `variable_${i}`).

**Other Alternatives:**

* Other approaches for creating an array of strings, such as using `Array.prototype.slice()`, `Array.prototype.concat()`, or custom iteration over the `count` value.
* Alternative ways to map over an array, such as using `forEach()` instead of `map()`.
* Using other methods to fill the array with zeros, such as `new Array(count).fill(0)`.

Keep in mind that these alternatives may have different performance characteristics and trade-offs.

Related benchmarks:

Push vs Create Fill and Map vs Create with Array.From (version: 0)

Comparing performance of: Push vs Create Array, fill and map vs Create with Array.from

Created: 2 years ago by: Guest

Jump to the latest result

Push

Create Array, fill and map

Create with Array.from

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