Benchmark: at(-1) vs slice(-1)[0] vs length - 1

Script Preparation code:

var array = Array({ length: 10000 }, (_, i) => i);

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 17 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
at(-1)	170825744.0 Ops/sec
length - 1	155702160.0 Ops/sec
slice(-1)[0]	58208616.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Definition**

The benchmark is testing three different ways to access the last element of an array:

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

These methods are being compared to determine which one is the fastest and most efficient.

**Options Compared**

The three options being compared are:

* `at(-1)`: This method uses the `Array.prototype.at()` method, which was introduced in ECMAScript 2022. It allows accessing an element at a specific index using a dot notation.
* `slice(-1)[0]`: This method uses the `Array.prototype.slice()` method to create a new array containing only the last element of the original array. The `-1` index is then used to access that element.
* `length - 1`: This method directly calculates the index of the last element by subtracting 1 from the length of the array.

**Pros and Cons**

Here's a brief overview of each approach:

* `at(-1)`: Pros:
	+ Concise syntax
	+ Expressive and readable
	+ Optimized for performance (according to the benchmark)
Cons:
	+ Introduced in ECMAScript 2022, so not supported in older browsers
	+ May require additional setup or polyfills for older browsers
* `slice(-1)[0]`: Pros:
	+ Widely supported across browsers and versions
	+ No dependency on newer ECMAScript features
Cons:
	+ Less concise syntax
	+ Creates a new array, which can be memory-intensive for large arrays
* `length - 1`: Pros:
	+ No additional dependencies required
	+ Fast and efficient calculation
Cons:
	+ Requires manual calculation of the index
	+ May not be as readable or expressive

**Library and Purpose**

There is no specific library mentioned in the provided JSON. However, `Array.prototype.at()` is a new method introduced in ECMAScript 2022, which allows accessing an element at a specific index using a dot notation.

**Special JS Feature**

The `at(-1)` method uses the `Array.prototype.at()` method, which is a special feature introduced in ECMAScript 2022. This feature allows accessing an element at a specific index using a dot notation, making the code more concise and expressive.

In summary, the benchmark is testing three different ways to access the last element of an array: `at(-1)`, `slice(-1)[0]`, and `length - 1`. The `at(-1)` method uses a new feature introduced in ECMAScript 2022, while `slice(-1)[0]` uses a widely supported approach but may create a new array. The `length - 1` method is a simple and efficient way to calculate the index but requires manual calculation.

**Alternatives**

Other alternatives for accessing the last element of an array include:

* Using `Math.max()` with `-Infinity` as the first argument: `Math.max(-Infinity, array[array.length - 1])`
* Using `Array.prototype.indexOf()` with `-1` as the target value: `array[array.length - 1] === array.indexOf(array[array.length - 1]) ? array[array.length - 1] : undefined`

These alternatives may offer different trade-offs in terms of performance, memory usage, and readability.

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

at(-1)

length - 1

slice(-1)[0]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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