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

Script Preparation code:

var array = [1,2,3];

Tests:

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

Historical Performance Data aggregated from 198 community runs

Desktop Results:

Chrome 158 runs

array.at(-1)

31.6M/s

array[array.length - 1]

17.5M/s

Fastest: array.at(-1) (1.8x faster)

View exact numbers

✓ array.at(-1): 31,635,868 ops/sec
• array[array.length - 1]: 17,517,538 ops/sec

Firefox 22 runs

array[array.length - 1]

1488.4M/s

array.at(-1)

975.1M/s

Fastest: array[array.length - 1] (1.5x faster)

View exact numbers

✓ array[array.length - 1]: 1,488,388,736 ops/sec
• array.at(-1): 975,132,992 ops/sec

Safari 7 runs

array.at(-1)

24.6M/s

array[array.length - 1]

16.8M/s

Fastest: array.at(-1) (1.5x faster)

View exact numbers

✓ array.at(-1): 24,567,316 ops/sec
• array[array.length - 1]: 16,793,016 ops/sec

Mobile Results:

Chrome 6 runs

array.at(-1)

14.0M/s

array[array.length - 1]

7.8M/s

Fastest: array.at(-1) (1.8x faster)

View exact numbers

✓ array.at(-1): 14,048,276 ops/sec
• array[array.length - 1]: 7,775,620 ops/sec

Safari 5 runs

array.at(-1)

25.9M/s

array[array.length - 1]

15.8M/s

Fastest: array.at(-1) (1.6x faster)

View exact numbers

✓ array.at(-1): 25,918,340 ops/sec
• array[array.length - 1]: 15,826,887 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36

Browser/OS: Chrome 143 on Mac OS X 10.15.7

View result in a separate tab

array[array.length - 1]

168.8M/s

array.at(-1)

164.1M/s

View exact numbers

Test name	Executions per second
✓ array[array.length - 1]	168,821,616 Ops/sec
array.at(-1)	164,110,704 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the benchmark.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark test case for two different ways of accessing the last element of an array: using `array[array.length - 1]` and `array.at(-1)`. The benchmark aims to compare the performance of these two approaches.

**Options Compared**

The benchmark compares two options:

1. **`array[array.length - 1]`**: This approach uses the standard array indexing syntax, where you access an element at a specific index using square brackets (`[]`). In this case, it's accessing the last element by subtracting 1 from the array length.
2. **`array.at(-1)`**: This approach uses the `at()` method, introduced in ECMAScript 2019 (ES11), which allows you to access elements at a specific index without having to worry about out-of-bounds errors.

**Pros and Cons**

Here are some pros and cons of each approach:

* **`array[array.length - 1]`**:
	+ Pros:
		- Widely supported in older browsers.
		- No additional library or feature required.
	+ Cons:
		- May require more careful handling to avoid out-of-bounds errors.
		- Less readable and maintainable, especially for larger arrays.
* **`array.at(-1)`**:
	+ Pros:
		- More concise and expressive syntax.
		- Better support for array bounds checking, reducing the risk of errors.
	+ Cons:
		- Requires ECMAScript 2019 (ES11) or later, which may not be supported in older browsers.

**Library**

In this benchmark, the `at()` method is used from the ECMAScript Standard Library. The purpose of `at()` is to provide a more expressive and safe way of accessing array elements at a specific index.

**Special JavaScript Feature**

The benchmark uses the `at()` method, which was introduced in ECMAScript 2019 (ES11). This feature allows you to access elements at a specific index using a safer and more readable syntax than traditional indexing.

**Other Considerations**

When considering these approaches, keep in mind that:

* For small arrays, the difference in performance may be negligible.
* For larger arrays or performance-critical code, `array.at(-1)` might offer a slight performance advantage due to its bounds checking.
* The choice between these approaches ultimately depends on your specific use case and the trade-offs you're willing to make between readability, maintainability, and performance.

**Other Alternatives**

If you need alternative ways to access array elements, consider:

* `array[-1]` (negative indexing): Accessing an element at a negative index, which can be useful for certain use cases.
* `array[Array.prototype.length - 1]`: Another way to access the last element of an array using standard indexing syntax.

Keep in mind that these alternatives may have different performance characteristics or trade-offs compared to the `at()` method.

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

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

Created: 4 years ago by: Registered User

Go to the latest result

array[array.length - 1]

array.at(-1)

Historical Performance Data aggregated from 198 community runs

Desktop Results:

Chrome 158 runs

Firefox 22 runs

Safari 7 runs

Mobile Results:

Chrome 6 runs

Safari 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

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

Created: 4 years ago by: Registered User

Go to the latest result

array[array.length - 1]

array.at(-1)

Historical Performance Data aggregated from 198 community runs

Desktop Results:

Chrome 158 runs

Firefox 22 runs

Safari 7 runs

Mobile Results:

Chrome 6 runs

Safari 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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