Benchmark: [i] vs .at(i) - MeasureThat.net

Script Preparation code:

var a = Array(100_000_000).fill(1);

Tests:

[i]
let total = 0; for (let i = 0; i < a.length; i++) { total += a[i]; }
.at(i)
let total = 0; for (let i = 0; i < a.length; i++) { total += a.at(i); }
?.[i]
let total = 0; for (let i = 0; i < a.length; i++) { total += a?.[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
[i]
.at(i)
?.[i]

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Android 13; Mobile; rv:108.0) Gecko/108.0 Firefox/108.0

Browser/OS: Firefox Mobile 108 on Android

View result in a separate tab

Test name	Executions per second
[i]	6.0 Ops/sec
.at(i)	4.2 Ops/sec
?.[i]	4.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and considered.

**Benchmark Definition**

The benchmark is defined by a JSON object that provides information about two approaches:

1. `[i]` (square bracket notation)
2. `.at(i)` (dot notation)

Both approaches are used to access elements in an array `a` with a length of 100 million elements, filled with the value 1.

**Script Preparation Code**

The script preparation code creates the array `a` and fills it with 100 million elements.

```javascript
var a = Array(100_000_000).fill(1);
```

This code is executed before running each test case.

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark only focuses on JavaScript performance.

**Test Cases**

There are three individual test cases:

1. `[i]`: This test case uses the square bracket notation to access elements in the array `a`.
2. `.at(i)`: This test case uses the dot notation to access elements in the array `a`.
3. `?.[i]`: This test case uses optional chaining (`.?`) followed by square bracket notation to access elements in the array `a`.

**Optional Chaining**

The test case `?.[i]` uses optional chaining, which is a feature introduced in ECMAScript 2020. Optional chaining allows you to access nested properties or arrays without throwing an error if they are undefined.

```javascript
total += a?.[i];
```

If `a[i]` is undefined, the expression will evaluate to `undefined` instead of throwing an error.

**Library and Features**

There is no library used in this benchmark. However, the use of optional chaining (`?.`) might be considered a feature of modern JavaScript.

**Performance Considerations**

The performance differences between these three approaches are likely due to the following factors:

1. **Accessing elements**: In the `[i]` case, we need to increment an index variable `i` for each iteration, which might introduce some overhead due to incrementation and array bounds checking.
2. **Dot notation vs. square bracket notation**: Dot notation is generally faster than square bracket notation because it uses a more optimized internal implementation (e.g., `Object.hasOwn(a, 'i')` instead of `a.hasOwnProperty('i')`).
3. **Optional chaining**: Optional chaining introduces an additional layer of indirection and might incur some overhead due to the possibility of the chained property being undefined.

**Benchmark Results**

The latest benchmark results show that:

1. `[i]`: 5.982 executions per second
2. `?.[i]`: 4.470 executions per second
3. `.at(i)`: 4.199 executions per second

Based on these results, the order of performance is: `[i]` > `?.[i]` > `.at(i)`.

**Alternatives**

Other alternatives to test this benchmark could include:

1. Using a different array size or distribution
2. Adding more complex calculations or operations inside the loops
3. Using a different programming language (e.g., C++, Java)
4. Implementing each approach in a different language (e.g., Rust, Go)

Keep in mind that these alternatives might change the focus of the benchmark and may not provide comparable results.

I hope this explanation helps! Let me know if you have any further questions.

Related benchmarks:

[i] vs .at(i) (version: 0)

Comparing performance of: [i] vs .at(i) vs ?.[i]

Created: one year ago by: Guest

Jump to the latest result

[i]

.at(i)

?.[i]

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