Benchmark: at method versus array index

Script Preparation code:

arr = Array.from({length: 1000}, (_, i) => i);

Tests:

Initial value indexing
const index_zero = arr[0]; console.log(index_zero);
Random value indexing
const index_random = arr[Math.floor(Math.random() * arr.length)]; console.log(index_random);
Last value indexing
const index_last = arr[arr.length - 1]; console.log(index_last);
Initial value at()
const at_zero = arr.at(0); console.log(at_zero);
Random value at()
const at_random = arr.at(Math.floor(Math.random() * arr.length)); console.log(at_random);
Last value at()
const at_last = arr.at(-1); console.log(at_last);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Initial value indexing
Random value indexing
Last value indexing
Initial value at()
Random value at()
Last value at()

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is a JSON object that describes the test to be performed. In this case, it compares the performance of `Array.prototype.at()` (the "at" method) with traditional indexing (using bracket notation, e.g., `arr[i]`) for retrieving elements from an array.

**Script Preparation Code**

The script preparation code is a JavaScript snippet that creates an array of 1000 elements using `Array.from()` and assigns it to the variable `arr`.

**Html Preparation Code**

There is no HTML preparation code provided, which suggests that this benchmark focuses solely on JavaScript performance.

**Individual Test Cases**

The benchmark consists of six test cases, each with a unique scenario:

1. **Initial value indexing**: Retrieves the first element of the array using traditional indexing (`arr[0]`).
2. **Random value indexing**: Retrieves a random element from the array using traditional indexing (`arr[Math.floor(Math.random() * arr.length)]`).
3. **Last value indexing**: Retrieves the last element of the array using traditional indexing (`arr[arr.length - 1]`).
4. **Initial value at()**: Retrieves the first element of the array using `Array.prototype.at(0)`.
5. **Random value at()**: Retrieves a random element from the array using `Array.prototype.at(Math.floor(Math.random() * arr.length))`.
6. **Last value at()**: Retrieves the last element of the array using `Array.prototype.at(-1)`.

**Library**

In all test cases, no libraries are explicitly mentioned, but `Array.from()` is used to create the array. This function is part of the ECMAScript standard and is supported by most modern browsers and Node.js environments.

**Special JavaScript Features**

The benchmark uses the following special JavaScript features:

* `Math.random()`: generates a random number between 0 (inclusive) and 1 (exclusive).
* `Array.prototype.at()`: provides a more concise way to access elements in an array, similar to C-style indexing. This method was introduced in ECMAScript 2022.

**Pros and Cons of Different Approaches**

Here's a brief analysis of the pros and cons of each approach:

* **Traditional indexing (e.g., `arr[0]`)**:
	+ Pros: widely supported, easy to understand.
	+ Cons: less readable and maintainable than other approaches.
* **Array.prototype.at()**:
	+ Pros: more concise, expressive, and readable.
	+ Cons: may have performance overhead due to the method's implementation.

**Other Alternatives**

If you're interested in exploring alternative approaches or optimizations for this benchmark, consider the following:

* Use `slice()` or `map()` instead of `Array.from()` to create the array.
* Optimize the random value indexing using a lookup table or caching mechanism.
* Profile your code and identify performance bottlenecks that may affect the results.

Keep in mind that these alternatives might not significantly impact the benchmark's overall outcome but can help you better understand the trade-offs involved.

Latest run results:

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

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Initial value indexing	228310.9 Ops/sec
Random value indexing	194717.2 Ops/sec
Last value indexing	206010.3 Ops/sec
Initial value at()	212103.4 Ops/sec
Random value at()	178106.7 Ops/sec
Last value at()	209302.3 Ops/sec

Related benchmarks:

at method versus array index (version: 0)

How does Array.prototype.at() performance compare to traditional indexing (arr[i]).

Comparing performance of: Initial value indexing vs Random value indexing vs Last value indexing vs Initial value at() vs Random value at() vs Last value at()

Created: one year ago by: Guest

Jump to the latest result

Initial value indexing

Random value indexing

Last value indexing

Initial value at()

Random value at()

Last value at()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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