Benchmark: Array.Prototype.at vs index

Tests:

Array.at()
const arr = ['a','b', 1, 2, true, false]; const val = arr.at(2);
Index
const arr = ['a','b', 1, 2, true, false]; const val = arr[2];

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 17 runs

Index

184.4M/s

Array.at()

161.6M/s

Fastest: Index (1.1x faster)

View exact numbers

✓ Index: 184,408,768 ops/sec
• Array.at(): 161,582,928 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.at()
Index

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

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

Browser/OS: Chrome 140 on Mac OS X 10.15.7

View result in a separate tab

Index

285.6M/s

Array.at()

273.7M/s

View exact numbers

Test name	Executions per second
✓ Index	285,566,912 Ops/sec
Array.at()	273,681,888 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

On MeasureThat.net, the provided benchmark tests the performance difference between two approaches to access an element in an array:

1. **`arr.at(2)`**: This method is used to access the 3rd element of the array (index 2) using the `Array.prototype.at()` method.
2. **`arr[2]`**: This is a direct index-based approach, accessing the 3rd element of the array by its numeric index.

**Options compared**

The benchmark compares these two approaches:

* **`Array.prototype.at(2)`**: This method is used to access an element in an array, and it's designed to be more intuitive and readable than traditional indexing.
* **Direct Indexing (`arr[2]`)**: This approach uses the numeric index of the desired element.

**Pros and Cons**

* **`Array.prototype.at(2)`**:
	+ Pros: More intuitive, readable, and maintainable code. It's also a good way to avoid off-by-one errors.
	+ Cons: Performance might be slower due to the overhead of this method.
* **Direct Indexing (`arr[2]`)**:
	+ Pros: Generally faster, as it avoids the overhead of the `at()` method.
	+ Cons: Less intuitive and less readable, which can lead to off-by-one errors.

In general, if code readability is important and maintainability is a concern, using `Array.prototype.at(2)` might be preferred. However, if performance is critical, direct indexing (`arr[2]`) would be the better choice.

**Other considerations**

* **Browser support**: The `at()` method was introduced in ECMAScript 2019 (ES10). If you need to support older browsers or environments that don't support this feature, direct indexing (`arr[2]`) might be a safer option.
* **Array size and performance**: As the array grows, the difference between these approaches may become less noticeable. However, for small arrays, direct indexing (`arr[2]`) will generally be faster.

**Library and special JS features**

There is no library involved in this benchmark. There are no special JavaScript features or syntax mentioned.

**Alternatives**

If you're interested in exploring other benchmarking options on MeasureThat.net, here are a few examples:

* Compare the performance of different array data structures (e.g., `ArrayBuffer`, `TypedArray`, etc.)
* Benchmark the speed of various JavaScript algorithms (e.g., sorting, searching, etc.)
* Test the performance of different JavaScript engines or browsers

Keep in mind that MeasureThat.net is primarily focused on measuring JavaScript performance and benchmarking microbenchmarks.

Array.Prototype.at vs index (version: 0)

Measures performance between using arr.at(1) to access an element in an array and arr[1]

Comparing performance of: `Array.at() vs Index`

Created: 2 years ago by: Guest

Go to the latest result

Array.at()

Index

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 17 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.Prototype.at vs index (version: 0)

Measures performance between using arr.at(1) to access an element in an array and arr[1]

Comparing performance of: Array.at() vs Index

Created: 2 years ago by: Guest

Go to the latest result

Array.at()

Index

Historical Performance Data aggregated from 17 community runs

Desktop Results:

Chrome 17 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.at() vs Index`