Benchmark: at VS slice VS length: who is the fastest to get last item

Script Preparation code:

var list = [];
for (var i = 0; i < 1000; i++) {
  list.push(i);
}

Tests:

at
last = list.at(-1);
slice
last = list.slice(-1)[0];
length
last = list[list.length -1]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
at
slice
length

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 27 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the provided JSON and analyze what's being tested.

**Benchmark Definition**

The benchmark is called "at VS slice VS length: who is the fastest to get last item". This name suggests that we're comparing three different methods to retrieve the last element of an array. The description is blank, but based on the test cases, it seems like we're measuring which method is the fastest.

**Test Cases**

We have three test cases:

1. **"at"**: `last = list.at(-1);`
2. **"slice"**: `last = list.slice(-1)[0];`
3. **"length"**: `last = list[list.length - 1];`

Let's break down each method:

* **`list.at(-1)`**: This uses the `at()` method, which returns the element at the specified index (in this case, `-1`, which is equivalent to the last element). The `-1` index is a special value in JavaScript that refers to the last element of an array.
* **`list.slice(-1)[0]`**: This uses the `slice()` method, which returns a new array containing a section (or "slice") of the original array. By passing `-1`, we're essentially getting the last element. We then access the first element (`[0]`) of this slice to get the desired result.
* **`list[list.length - 1]`**: This uses direct indexing, where we access the last element by its index (calculated as `list.length - 1`). This is a simple and straightforward approach.

**Libraries and Features**

There are no external libraries used in this benchmark. The JavaScript code only relies on built-in array methods (`at()`, `slice()`, and direct indexing).

**Pros and Cons of Each Method**

Based on the results, here's a brief analysis:

* **`at()`**: This method is generally fast, but it may have some overhead due to its use in the browser's JavaScript engine. In this case, it's slightly faster than `slice()`.
* **`slice()`**: While not as fast as `at()`, `slice()` can be a good alternative if you need to get multiple elements from an array (not just the last one). However, using `-1` as an index might lead to unnecessary copying of the array.
* **Direct Indexing (`list[list.length - 1]`)**: This method is simple and efficient but may not be as readable or maintainable as other approaches. It's also slower than `at()` in this case.

**Other Alternatives**

Other ways to get the last element of an array include:

* Using a loop to iterate through the array and find the last element.
* Utilizing a library like Lodash, which provides its own implementation for getting the last element (e.g., `_.last()`).
* Converting the array to a string using `join()`, then accessing the last character.

Keep in mind that these alternatives might have different performance characteristics depending on your specific use case and environment.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
at	5073019.5 Ops/sec
slice	4382097.0 Ops/sec
length	3993015.8 Ops/sec

Related benchmarks:

at VS slice VS length: who is the fastest to get last item (version: 0)

Comparing performance of: at vs slice vs length

Created: one year ago by: Guest

Jump to the latest result

at

slice

length

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 27 days ago):