Benchmark: arr.at(-1) vs arr[arr.length-1]

Script Preparation code:

var data = Array(1000000).fill({ filtering: true, mapping: 42 });

Tests:

Test length
data[data.length - 1]
Test at
data.at(-1)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test length
Test at

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36

Browser/OS: Chrome 143 on Linux

View result in a separate tab

Test name	Executions per second
Test length	212702448.0 Ops/sec
Test at	190131504.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**Benchmark Definition**

The primary test case measures the access speed of two different ways to access the last element of an array:

1. `arr.at(-1)`
2. `arr[arr.length-1]`

These two approaches are used to compare their performance, with the goal of determining which one is faster and more efficient.

**Options Compared**

We have two main options being compared:

1. **`at()` method**: Introduced in ECMAScript 2019 (ES9), this method provides a safer way to access array elements by their index, without throwing an error if the index is out of bounds.
2. **Subscript notation (`[]`) with `length` property**: This is the traditional way of accessing array elements using their index.

**Pros and Cons**

### `at()` Method

Pros:

* Provides a safer way to access array elements by their index, without throwing an error if the index is out of bounds.
* Can be more efficient than the subscript notation for large arrays, as it avoids the overhead of checking the length property.

Cons:

* Requires ECMAScript 2019 (ES9) support, which might not be available in older browsers or environments.
* May have a performance overhead compared to the subscript notation for small arrays.

### Subscript Notation (`[]`) with `length` Property

Pros:

* Widely supported across different browsers and environments, including older ones.
* Can be faster than the `at()` method for small arrays.

Cons:

* Can throw an error if the index is out of bounds.
* May have a performance overhead compared to the `at()` method for large arrays.

**Library**

There are no libraries mentioned in this benchmark. The tests only rely on built-in JavaScript features.

**Special JS Feature or Syntax**

The `at()` method is a special feature introduced in ECMAScript 2019 (ES9), which allows safe array indexing without throwing an error if the index is out of bounds. This syntax was not available in earlier versions of JavaScript.

**Other Considerations**

When evaluating these two approaches, it's essential to consider the size and complexity of the arrays being accessed, as well as the specific requirements of your application. For small arrays or simple use cases, the subscript notation might be sufficient and faster. However, for large arrays or performance-critical code paths, the `at()` method can provide a safer and potentially more efficient alternative.

**Alternatives**

Other alternatives to access the last element of an array include:

1. Using the `pop()` method: This removes the last element from the array and returns it.
2. Creating a new array with the last element using the spread operator (`[...]`): This creates a new array containing only the last element.

These alternatives may have different performance characteristics and use cases compared to the `at()` method and subscript notation.

Related benchmarks:

arr.at(-1) vs arr[arr.length-1] (version: 0)

Test access speed

Comparing performance of: Test length vs Test at

Created: 2 years ago by: Guest

Jump to the latest result

Test length

Test at

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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