Benchmark: Array last index

Script Preparation code:

var arr = [];
for (let i = 0; i < 1000000; i++) {
  arr.push(i);
}

Tests:

Slice
for (let i = 0; i < 1000; i++) { const v = arr.slice(-1)[0]; }
Length - 1
for (let i = 0; i < 1000; i++) { const v = arr[arr.length - 1]; }
Pop
for (let i = 0; i < 1000; i++) { const v = arr.pop(); }
Reverse
for (let i = 0; i < 1000; i++) { const v = arr.reverse()[0]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Slice
Length - 1
Pop
Reverse

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Test name	Executions per second
Slice	22208.3 Ops/sec
Length - 1	12874.5 Ops/sec
Pop	28684.5 Ops/sec
Reverse	25111.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**What is tested?**

MeasureThat.net tests the performance of different ways to access the last element of an array in JavaScript. The benchmark defines a single script that creates a large array, and then runs multiple test cases that use different methods to retrieve the last element.

**Options compared**

The benchmark compares four options:

1. **`arr.slice(-1)[0]`**: This method uses the `slice()` function to create a new array with only the last element, and then extracts that element using indexing (`[0]`). This approach is often used when you need to process arrays in chunks or extract a specific subset.
2. **`arr[arr.length - 1]`**: This method directly accesses the last element of the original array using indexing. This approach is simple and efficient, but it can be less readable than the other options.
3. **`arr.pop()`**: This method removes and returns the last element of the array. While this approach modifies the original array, it's often used when you need to remove an item from the end of the array without preserving its position in the sequence.
4. **`arr.reverse()[0]`**: This method reverses the entire array using the `reverse()` function and then extracts the first element (i.e., the last element of the original array). This approach is often used when you need to process arrays in reverse order.

**Pros and Cons**

Here's a brief summary of each option:

* **`arr.slice(-1)[0]`**: Pros: efficient, doesn't modify the original array. Cons: creates a new array object, can be slower for very large arrays.
* **`arr[arr.length - 1]`**: Pros: simple, fast. Cons: modifies indexing behavior, may not work as expected if array is empty or has only one element.
* **`arr.pop()`**: Pros: removes item from end of array without preserving position, can be useful for certain use cases. Cons: modifies original array, can be slower than direct indexing.
* **`arr.reverse()[0]`**: Pros: reverses entire array, extracts last element. Cons: slows down array reversal process, creates new array object.

**Library and purpose**

There is no specific library mentioned in the benchmark definition or test cases. However, `slice()` and `pop()` are built-in JavaScript methods that work directly on arrays. The only custom code in the script preparation code is the creation of a large array using a loop.

**Special JS features or syntax**

There aren't any special JavaScript features or syntax mentioned in the benchmark definition or test cases. However, it's worth noting that `let` and `const` are used for variable declarations, which was introduced in ECMAScript 2015 (ES6).

**Other alternatives**

If you're looking for alternative approaches to access the last element of an array, here are a few options:

* **Using `Array.prototype.at()`**: Introduced in ECMAScript 2020, this method provides a safer and more efficient way to access elements at specific positions in arrays.
* **Using a custom function or utility library**: Depending on your use case, you might need to write a custom function or use an existing utility library that provides an optimized way to extract the last element of an array.

Keep in mind that these alternatives may not be suitable for all scenarios and should be carefully evaluated based on your specific requirements.

Related benchmarks:

Array last index (version: 0)

Comparing performance of: Slice vs Length - 1 vs Pop vs Reverse

Created: 2 years ago by: Guest

Jump to the latest result

Slice

Length - 1

Pop

Reverse

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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