Benchmark: fill test - MeasureThat.net

Script Preparation code:

let i, length = 1_000

Tests:

fill index
const a = new Array(length) for(i = 0; i < length; i++) a[i] = 0
fill from
const a = Array.from({length}).fill(0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
fill index
fill from

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the provided benchmark and its various aspects.

**Benchmark Definition**

The benchmark is created using JSON, which provides the necessary information for running the test cases. The key elements of the benchmark definition are:

*   **Name**: "fill test"
*   **Description**: None (no description is provided for this benchmark)
*   **Script Preparation Code**: A JavaScript code snippet that initializes variables and sets up the environment for the test case.
    *   `let i, length = 1_000`: This line declares a variable `i` and assigns it a value of 0. The variable `length` is also declared with an initial value of 1000. These variables are used in the subsequent code snippets.
*   **Html Preparation Code**: None (no HTML preparation code is provided)

**Individual Test Cases**

There are two test cases defined:

1.  **"fill index"`**
    *   The benchmark definition for this test case is:
        ```javascript
const a = new Array(length)
for(i = 0; i < length; i++) a[i] = 0
```
    *   This code creates an array `a` with the specified length and then iterates over each element, setting it to 0.

2.  **"fill from"`**
    *   The benchmark definition for this test case is:
        ```javascript
const a = Array.from({length}).fill(0)
```
    *   This code uses `Array.from()` to create an array with the specified length and then fills each element with a value of 0.

**Comparing Options**

The two options being compared are:

*   **Using `new Array(length)`**: This method creates an array by calling the constructor function directly, passing in the desired length. It is more traditional but can be slower for large arrays due to the overhead of creating an array object.
*   **Using `Array.from({length}).fill(0)`**: This method uses the `Array.from()` factory function to create an array from a specified iterable (in this case, an object with a `length` property) and then fills each element with a value. It is more modern but can be slower due to the additional overhead of using `Array.from()`.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

*   **Using `new Array(length)`**
    *   Pros:
        +   More traditional and widely supported
        +   Often faster than using `Array.from()`
    *   Cons:
        +   Can be slower for large arrays due to overhead

*   **Using `Array.from({length}).fill(0)`**
    *   Pros:
        +   Modern and widely used in many modern browsers
        +   Can be more efficient for larger arrays (although the difference is usually negligible)
    *   Cons:
        +   Slower than using `new Array(length)` due to additional overhead

**Library/Features**

Neither of these approaches requires any specific libraries or features. They are both built-in JavaScript methods.

No special JavaScript features or syntax are used in these benchmark test cases, but they do demonstrate a fundamental aspect of JavaScript arrays: creating and populating them using different methods.

**Alternative Approaches**

If you're looking for alternative ways to create an array with a specified length, you could also use:

*   **`Array.prototype.fill()`**: This method fills all elements in the current array with a given value.
    *   Example:
        ```javascript
const a = new Array(length)
a.fill(0)
```
*   **`Array.from()`** (again): While `Array.from()` is used in this benchmark, it's also worth noting that you can create an array from a range of values using the `Array.from(range)` syntax. However, this approach doesn't require specifying the length explicitly and would fill all elements up to the last value in the range.

Keep in mind that these alternative approaches might not be as efficient or have the same performance characteristics as the original methods used in the benchmark.

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
fill index	1461358.1 Ops/sec
fill from	1704043.0 Ops/sec

Related benchmarks:

fill test (version: 0)

Comparing performance of: fill index vs fill from

Created: 3 months ago by: Registered User

Jump to the latest result

fill index

fill from

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