Benchmark: at vs length - MeasureThat.net

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) arr[i] = i++;

Tests:

Array.prototype.at
const last = arr.at(-1);
length
const length = arr.length const lastwithlength = arr[length-1]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.at
length

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/117.0

Browser/OS: Firefox 117 on Linux

View result in a separate tab

Test name	Executions per second
Array.prototype.at	599139392.0 Ops/sec
length	831661504.0 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 and explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark is defined in JSON format, which represents two test cases:

1. `at vs length`: This test case measures which approach is faster for accessing the last element of an array.
2. Two individual test cases:
	* `Array.prototype.at`
	* `length`

**Script Preparation Code**

The script preparation code is identical for both test cases and creates a large array with 100,000 elements using a while loop.

```javascript
var arr = [];
var i = 0;

while (i <= 1E5) {
  arr[i] = i++;
}
```

This code ensures that the array has enough elements to make accessing its last element meaningful.

**Html Preparation Code**

The HTML preparation code is empty for both test cases, which means that no additional setup or configuration is required beyond what's in the script preparation code.

**Options Compared**

For each test case, two approaches are compared:

1. `Array.prototype.at`
2. `length`

Both approaches aim to access the last element of the array (`arr[100000]`), but they differ in how it's done.

**Approach 1: `Array.prototype.at`**

This approach uses the `at()` method, which returns a reference to the element at the specified index (0-based). The syntax is:
```javascript
const last = arr.at(-1);
```

Pros:

* Concise and readable syntax.
* Avoids manual indexing.

Cons:

* May incur additional overhead due to the existence of the `at()` method, which might not be optimized for performance in older browsers or versions of Node.js.
* Can fail if the array is not sorted or has duplicate indices (although this is unlikely).

**Approach 2: Using `length`**

This approach uses the length property of the array to calculate the index and then accesses the element using square bracket notation:
```javascript
const lastwithlength = arr[length-1];
```

Pros:

* More explicit and potentially faster since it avoids the overhead of a method call.
* Works for arrays with duplicate indices.

Cons:

* Less concise and readable syntax compared to `Array.prototype.at`.
* May require additional calculations, which could lead to performance issues in some cases.

**Library: None**

There are no external libraries used in this benchmark.

**Special JS Feature or Syntax: None**

No special JavaScript features or syntax is used in this benchmark.

**Other Considerations**

* The benchmark assumes that the array's length does not change during the execution of the script. If the array may change, using `at()` might be a better choice to avoid off-by-one errors.
* The benchmark uses a large array with 100,000 elements, which is likely optimized for performance in most modern browsers and Node.js versions.

**Alternatives**

If you want to explore alternative approaches or libraries, here are some options:

* Use `Array.prototype.slice()` instead of `at()`. While slower than `at()`, it's more explicit and might be a better choice if you're working with large arrays.
* Consider using `TypedArray` objects (e.g., `Int32Array`) for performance-critical code. These arrays are optimized for performance and might offer significant speedups.
* Look into the `optimize_for` parameter in Node.js V8, which allows you to specify the optimization level for your benchmark.

Keep in mind that these alternatives may require additional setup or changes to your script preparation code.

Related benchmarks:

at vs length (version: 0)

Measuring which is faster

Comparing performance of: Array.prototype.at vs length

Created: one year ago by: Guest

Jump to the latest result

Array.prototype.at

length

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