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

Script Preparation code:

var array = [1, 2, 3];

function last1(array) {
    return array[array.length - 1]
}

function last2(array) {
    return array.at(-1)
}

Tests:

array[array.length - 1]
var d = array[array.length - 1];
array.at(-1)
var z = array.at(-1);
array[array.length - 1] fn
var x = last1(array);
array.at(-1) fn
var y = last2(array);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array[array.length - 1]
array.at(-1)
array[array.length - 1] fn
array.at(-1) fn

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Windows

View result in a separate tab

Test name	Executions per second
array[array.length - 1]	3274011648.0 Ops/sec
array.at(-1)	2454609408.0 Ops/sec
array[array.length - 1] fn	3325238784.0 Ops/sec
array.at(-1) fn	2463201792.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark presented tests the performance of two different methods for retrieving the last element of an array in JavaScript. This is performed through two direct methods of accessing the last element and two corresponding functions that wrap these methods.

### Methods Compared

1. **Direct Access via Indexing**: 
   - `array[array.length - 1]`
   - This method retrieves the last element of the array using the length property, subtracting one to get the index of the last element.

2. **Using the `at()` Method**: 
   - `array.at(-1)`
   - The `at()` method is a built-in JavaScript method introduced in ES2022 that allows you to access elements in the array using negative integers, where `-1` references the last element.

### Function Wrappers

Additionally, the benchmark tests functions that encapsulate these methods:
- `last1(array)` calls the first method (`array[array.length - 1]`).
- `last2(array)` calls the second method (`array.at(-1)`).

### Performance Evaluation

Each of the methods and their corresponding function wrappers is tested, and the performance is measured in terms of **Executions Per Second** (EPS). The results show the number of times each test can be executed within a second.

1. **Results Summary**:
   - `last1(array)`: 134,701,488 EPS
   - Direct indexing `array[array.length - 1]`: 131,060,624 EPS
   - `last2(array)`: 38,496,756 EPS
   - `array.at(-1)`: 37,834,628 EPS

### Analysis of Pros and Cons

1. **Direct Indexing (`array[array.length - 1]`)**:
   - **Pros**:
     - It is a widely-used and well-known method among JavaScript developers, making it easily understandable.
     - Generally, it has higher performance in this benchmark.
   - **Cons**:
     - Less readable for those not familiar with the length property, especially when dealing with negative indices.

2. **Using `at()` Method (`array.at(-1)`)**:
   - **Pros**:
     - More readable and concise, providing clarity when accessing elements with negative indices.
     - Does not require calculation (subtracting one from the length).
   - **Cons**:
     - Slower performance compared to direct indexing in this benchmark.
     - It may not be available in older JavaScript environments, making it unsuitable for legacy support.

### Other Considerations

- **Browser Compatibility**: While `array.at()` is part of the ECMAScript standard and supported in modern browsers, developers must consider compatibility with older browsers that might not support ES2022 features.
  
- **Code Readability**: The choice between using direct indexing versus `at()` might depend on the team's code style preference and the desire for clarity versus performance.

### Alternatives

1. **Lodash Library**: A utility library that offers various array manipulation features, including functions like `.last()` that can retrieve the last element of an array. A potential usage would be `_.last(array)`, which can also improve readability but usually comes with more overhead from the library itself.
  
2. **Custom Helper Functions**: Developers can create custom utility functions tailored to their specific application needs. However, care should be taken to ensure that they optimize performance and maintain readability.

This benchmark is a straightforward illustration of choosing the best approach based on both performance and developer experience. By understanding the differences and performance characteristics of these methods, engineers can make informed choices in their JavaScript applications.

Related benchmarks:

array[array.length - 1] vs array.at(-1) v2 (version: 1)

Comparing performance of: array[array.length - 1] vs array.at(-1) vs array[array.length - 1] fn vs array.at(-1) fn

Created: one year ago by: Registered User

Jump to the latest result

array[array.length - 1]

array.at(-1)

array[array.length - 1] fn

array.at(-1) fn

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):