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

Script Preparation code:

var array = [1,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3];

Tests:

array[array.length - 1]
return array[array.length - 1];
array.at(-1)
return 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: one month ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Overview**

MeasureThat.net is a platform where users can create and run JavaScript benchmarks to compare different approaches to achieve optimal performance. In this case, we have two test cases: `array[array.length - 1]` and `array.at(-1)`.

**Test Case Description**

The first test case uses the `array.length` property to access the last element of an array (`array[array.length - 1]`). The second test case uses the `at()` method with negative indexing to achieve the same result (`array.at(-1)`).

**Comparison Options**

We have two options being compared:

* **Direct indexing**: Using the `[ ]` notation to access the last element of an array.
* **at() method**: Using the `at()` method with negative indexing to access the last element of an array.

**Pros and Cons**

Here are some pros and cons of each approach:

**Direct Indexing (array[array.length - 1])**:

Pros:

* Native JavaScript syntax
* Faster execution (since it's a direct property access)
* Less memory allocation required

Cons:

* May not be as readable or maintainable for complex arrays
* Can lead to off-by-one errors if the array length is used incorrectly

**at() Method (array.at(-1))**

Pros:

* More readable and intuitive syntax, especially for large arrays
* Reduces the risk of off-by-one errors
* Better support for array methods in modern JavaScript (e.g., `filter()`, `map()`)

Cons:

* May be slower than direct indexing due to the method call overhead
* Requires a newer JavaScript engine that supports the `at()` method (Chrome 116 and later)

**Library Usage**

The test case uses the built-in `Array` object, which is a part of the JavaScript standard library. The `at()` method was introduced in ECMAScript 2019 (ES2020) and is now supported by most modern browsers.

**Special JS Feature/Syntax**

There is no special JS feature or syntax used in these test cases. However, it's worth noting that the use of negative indexing (`array.at(-1)`) might require JavaScript engines to optimize for performance.

**Other Alternatives**

If you want to explore other approaches, here are a few alternatives:

* Using `Array.prototype.slice()` with a negative index: `array.slice(-1)` (similar to `at()`, but without the `at()` method)
* Using `Array.prototype.pop()` or `Array.prototype.shift()`: These methods can be used to access the last element of an array, but they may have different performance characteristics and side effects compared to direct indexing or the `at()` method.
* Using a library like Lodash (`_.last(array)`): While not necessary for this specific test case, libraries like Lodash provide additional utility functions that can simplify array operations.

Keep in mind that these alternatives might not be as efficient or readable as the original test cases.

Related benchmarks:

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

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

Created: one year 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 llama3.2:3b, generated one month ago):