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

Script Preparation code:

var arr = Array(100000).fill(1);

Tests:

arr.slice(-1)[0]
arr[arr.length - 1];
arr.at(-1)
arr[arr.length - 1];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
arr.slice(-1)[0]
arr.at(-1)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the JavaScript microbenchmark.

**What is being tested?**

The provided benchmark is comparing two approaches to accessing the last element of an array in JavaScript:

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

These three options are being compared to determine which one is the fastest.

**Options comparison**

Here's a brief overview of each option:

1. **`arr.at(-1)`**: This method was introduced in ECMAScript 2019 (ES11) as part of the Array.prototype.at() method, which provides an alternative way to access array elements by their index or property key.
2. **`arr[arr.length - 1]`**: This is a common and straightforward approach to accessing the last element of an array in JavaScript. It involves concatenating the string representation of `arr.length` with `-1`, creating a new expression that calculates the index, and then using it to access the element.
3. **`arr.slice(-1)[0]`**: This method uses the `slice()` method to create a shallow copy of the array's last element, and then accesses the first (and only) element of the resulting array.

**Pros and Cons of each approach**

Here are some pros and cons for each option:

1. **`arr.at(-1)`**
	* Pros:
		+ More readable and expressive code
		+ Less error-prone than concatenating `arr.length` with `-1`
	* Cons:
		+ Only supported in modern browsers (ES11+)
		+ May not be compatible with older JavaScript engines or environments
2. **`arr[arr.length - 1]`**
	* Pros:
		+ Widespread support across various browsers and JavaScript engines
		+ Simple and concise code
	* Cons:
		+ Can be error-prone if the calculation is incorrect (e.g., `arr[0]`)
3. **`arr.slice(-1)[0]`**
	* Pros:
		+ More explicit and safe than concatenating `arr.length` with `-1`
		+ Still widely supported
	* Cons:
		+ Requires an additional method call (`slice()`) which can be slower

**Library usage**

There is no library used in this benchmark. All the code is native JavaScript.

**Special JS feature or syntax**

No special features or syntax are mentioned in the provided benchmark.

**Other alternatives**

If you need to access array elements, other alternatives could include:

1. **`for...in` loop**: Accessing elements using a `for...in` loop can be slower than array methods.
2. **Index calculation using `Math.floor()`**: Using `Math.floor(arr.length / 2)` or similar calculations to estimate the middle index can be slower and less accurate than using array methods.

Keep in mind that the choice of approach depends on the specific use case, performance requirements, and compatibility constraints.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
arr.slice(-1)[0]	14038803.0 Ops/sec
arr.at(-1)	14094083.0 Ops/sec

Related benchmarks:

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

Comparing performance of: arr.slice(-1)[0] vs arr.at(-1)

Created: one year ago by: Guest

Jump to the latest result

arr.slice(-1)[0]

arr.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):