Benchmark: For .. of vs For i

Script Preparation code:

var arr = [1, 2, 3, 4, 5, 6, 7, 8, "hello", { key: "value" }, 11]

Tests:

for .. of
for (let item of arr) { console.log(item); }
for i
for (let i = 0; i < arr.length; i++) { console.log(arr[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for .. of
for i

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; ONEPLUS A5000) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Mobile Safari/537.36

Browser/OS: Chrome Mobile 84 on Android

View result in a separate tab

Test name	Executions per second
for .. of	2196.8 Ops/sec
for i	2201.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark is defined by a JSON object that specifies two different approaches for looping through an array: `for .. of` and `for i`. The script preparation code includes a sample array `arr` with various data types, including strings and objects.

**Options Compared**

In this benchmark, we're comparing the performance of two loop constructs:

1. **`for .. of`**: This is an iterative loop that uses the `for ... of` syntax to iterate over the elements of an iterable object (in this case, the `arr` array). The loop variable is declared using the `let` keyword and takes on the value of each element in the iteration.
2. **`for i`**: This is a traditional iterative loop that uses the `for` keyword with an index variable (`i`) to access each element in the array.

**Pros and Cons**

Here are some pros and cons of each approach:

*   **`for .. of`**
    *   Pros:
        *   More concise and readable syntax
        *   Less prone to off-by-one errors (as the loop variable is not an index)
        *   Can be more efficient for arrays with a small number of elements
    *   Cons:
        *   May have performance overhead due to string interpolation or other string manipulation
        *   Not supported in older browsers or environments that don't support modern JavaScript features
*   **`for i`**
    *   Pros:
        *   More widely supported across different browsers and environments
        *   Can be more efficient for large arrays, as it avoids the overhead of string interpolation
    *   Cons:
        *   More prone to off-by-one errors (as the loop index can be easily misinterpreted)
        *   Less readable syntax

**Libraries Used**

In this benchmark, no specific library is used. However, MeasureThat.net often uses libraries like `fast-assert` or `console-testify` for assertion and logging purposes.

**Special JS Features**

There are no special JavaScript features (like async/await or arrow functions) mentioned in this benchmark. The code only uses the basic `for` loop constructs and standard array operations.

**Other Alternatives**

If you're looking for alternatives to these loop constructs, here are some options:

*   **`forEach()`**: This is a more concise way to iterate over an array without using a traditional `for` loop.
    ```javascript
arr.forEach((item) => {
  console.log(item);
});
```
*   **`map()`**, **`filter()`, and **`reduce()`****: These are array methods that can be used for operations like filtering, mapping, or reducing data. However, they may not be suitable for simple iteration over an array.
    ```javascript
const results = arr.map((item) => item * 2);
```
*   **`while` loops**: If you need more control over the loop, `while` loops can be used instead of traditional `for` loops.

Keep in mind that each approach has its trade-offs and may not always be suitable for every situation.

Related benchmarks:

For .. of vs For i (version: 0)

Comparing performance of: for .. of vs for i

Created: 4 years ago by: Guest

Jump to the latest result

for .. of

for i

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