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

Script Preparation code:

var array = new Array(1e5).fill(1);

Tests:

array[array.length - 1]
var d = array[array.length - 1];
array.at(-1)
var z = array.at(-1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 135 on Ubuntu

View result in a separate tab

Test name	Executions per second
array[array.length - 1]	1046637376.0 Ops/sec
array.at(-1)	956520192.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

In this benchmark, we are comparing two different ways to access the last element of an array in JavaScript:

1. **Traditional Array Indexing**: `array[array.length - 1]`
   - This approach uses the length of the array to calculate the index of the last element. Since arrays are zero-indexed, the last element is at the index of the total length minus one.

2. **Using `Array.prototype.at()` Method**: `array.at(-1)`
   - The `.at()` method was introduced in ECMAScript 2022 (ES13). It allows specifying an index directly, including negative indices, which count backwards from the end of the array. Thus, `array.at(-1)` effectively retrieves the last element of the array.

### Performance Comparison:

The benchmark results indicate the following executions per second for each method:
- **Traditional Array Indexing**: 98,299,112 executions per second.
- **Array.at() Method**: 91,300,032 executions per second.

### Pros and Cons:

#### 1. Traditional Array Indexing (`array[array.length - 1]`):
- **Pros**:
  - Ubiquitous and widely understood approach in JavaScript, compatible with all browsers.
  - Typically faster in performance benchmarks in this case.
  
- **Cons**:
  - Requires calculation using `array.length`, which adds a slight overhead, especially for large arrays.
  - Can lead to slightly less readable code due to arithmetic for those unfamiliar with it.

#### 2. Using `Array.prototype.at()` (`array.at(-1)`):
- **Pros**:
  - More readable and expressive, especially with negative indices emphasizing that we're accessing elements relative to the array’s end.
  - Eliminates the need for length calculations, potentially improving clarity and reducing chances of off-by-one errors.

- **Cons**:
  - Slightly less performant than traditional indexing in this specific benchmark.
  - Requires a more recent JavaScript environment (ES13), which may not be available in older browsers or legacy systems.

### Other Considerations:
- **Browser Compatibility**: Since `Array.at()` is a newer feature, developers must ensure compatibility with the target environments. While modern browsers support it, developers targeting older browsers should consider using traditional indexing for broader support.
- **Use Cases**: While performance is a consideration, readability and maintainability of code can be equally important, especially in larger codebases or teams. Developers might choose `Array.at()` for its clarity even if it's marginally slower.

### Other Alternatives:
- You could also consider using libraries like **Lodash**, which offers utility functions for common tasks. For example, `_.last(array)` can achieve the same goal in a clearer way, but this would introduce additional overhead in terms of library weight unless Lodash is already being used in the project.

In summary, the benchmark helps to highlight a key decision for developers: whether to prioritize performance and use traditional indexing or to opt for the clarity and elegance of `Array.at()` at a cost of some performance. The choice may vary based on the specific requirements and context of the application being developed.

Related benchmarks:

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

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

Created: 2 months ago by: Guest

Jump to the latest result

array[array.length - 1]

array.at(-1)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):