Benchmark: Array: [] vs at() last index

Script Preparation code:

var size = 0xffffff;
var data = Array.from({length: size}, (_, index) => index);

Tests:

Array[] array.length - 1
let sum = 0; for (let i; i < size; i++) { sum += data[array.length - 1]; }
Array.at() -1
let sum = 0; for (let i; i < size; i++) { sum += data.at(-1); }
Array[] cached array.length - 1
let sum = 0; let length = data.length; for (let i; i < size; i++) { sum += data[length -1]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
Array[] array.length - 1	34375700.0 Ops/sec
Array.at() -1	35951580.0 Ops/sec
Array[] cached array.length - 1	33454528.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark tests various methods for accessing the last element of an array in JavaScript. The test compares three approaches:

1. **Direct Access Using Array Length**: 
   ```javascript
   sum += data[array.length - 1];
   ```
   - **Description**: This method accesses the last element of the array by first obtaining the length and then subtracting one from it.
   - **Pros**: It is straightforward and clear; this is a conventional way of accessing array elements using their index.
   - **Cons**: In scenarios where the array length is accessed multiple times (e.g., in a loop), it leads to redundant calculations since `array.length` is computed with every iteration.

2. **Using Array.at()**: 
   ```javascript
   sum += data.at(-1);
   ```
   - **Description**: This method utilizes the `Array.at()` method, which allows fetching elements at negative indices. In this case, `-1` refers to the last element.
   - **Pros**: The syntax is concise and eliminates the need for explicit length computation, making it more readable.
   - **Cons**: While `Array.at()` is a more modern feature, it may not be supported in all environments (especially older browsers), requiring consideration of compatibility.

3. **Caching Array Length**: 
   ```javascript
   let length = data.length;
   sum += data[length -1];
   ```
   - **Description**: This approach caches the length of the array in a variable (`length`) to avoid recalculating it in every iteration.
   - **Pros**: This method provides a balance between clarity and performance since it reduces redundancy in length calculations while maintaining the conventional access pattern.
   - **Cons**: It still retains some overhead from the calculation of the index despite caching it.

### Alternative Considerations
- **Performance**: In large datasets, performance differences can be notable. The `Array.at()` method showed the best performance in the benchmark, followed by caching the length, and then the direct access method.
- **Browser Compatibility**: Developers must check whether `Array.at()` is compatible with the environments they are targeting. While modern browsers support it, older ones do not.
- **Array Methods**: Alternatives, such as using a library like Lodash, can provide utility functions for array manipulations. However, they introduce a dependency and may not perform as efficiently for trivial operations like accessing an index.

In summary, the benchmark provides meaningful insights into the efficiency of accessing the last element of an array using different methods. The `Array.at()` method, shown to be the fastest, demonstrates both syntactical elegance and performance efficiency. However, developers need to be mindful of browser compatibility when adopting newer features.

Related benchmarks:

Array: [] vs at() last index (version: 1)

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

Created: one year ago by: Guest

Jump to the latest result

Array[] array.length - 1

Array.at() -1

Array[] cached array.length - 1

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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