Benchmark: last array element

Script Preparation code:

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

Tests:

list.slice(-1)[0]
list.slice(-1)[0]
list[list.length -1]
list[list.length -1]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
list.slice(-1)[0]
list[list.length -1]

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 83 on Mac OS X 10.15.1

View result in a separate tab

Test name	Executions per second
list.slice(-1)[0]	9967568.0 Ops/sec
list[list.length -1]	7201419.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the provided benchmark.

**What is being tested?**

The provided benchmark tests two different ways to access the last element of an array in JavaScript:

1. Using `list.slice(-1)[0]`
2. Using `list[list.length - 1]`

**Options compared:**

Both methods are used to access the last element of an array, but they have some differences:

* **`list.slice(-1)`**: This method returns a new array containing only the last element of the original array. It then accesses this element using `[0]`.
* **`list[list.length - 1]`**: This method directly accesses the last element of the array by specifying its index as `length - 1`.

**Pros and Cons:**

* **`list.slice(-1)[0]`**:
	+ Pros:
		- More readable and maintainable code, especially for those familiar with string slicing (e.g., `str.substring(str.length - 1)`).
		- Less error-prone, as it creates a new array that can't be modified unexpectedly.
	+ Cons:
		- Creates a new array object, which may incur additional memory overhead.
* **`list[list.length - 1]`**:
	+ Pros:
		- More efficient in terms of memory usage, as it doesn't create a new array object.
		- Can be faster for large arrays, since it avoids the creation of an intermediate array.
	+ Cons:
		- Less readable and maintainable code, especially for those not familiar with indexing arrays by length.
		- More error-prone, as incorrect indexing can lead to unexpected behavior or errors.

**Library:**

There is no explicit library mentioned in the benchmark definition. However, it's worth noting that `slice()` method is a built-in JavaScript function, so there are no external dependencies required.

**Special JS feature or syntax:**

Neither of the tested methods relies on any special JavaScript features or syntax beyond standard array indexing and slicing.

**Other alternatives:**

For accessing the last element of an array, other alternatives could include:

* **`Array.prototype[Array.prototype.length - 1]`**: Similar to `list[list.length - 1]`, but uses a more concise syntax.
* **`Array.at(-1)`**: Introduced in ECMAScript 2019 (ES2020), this method provides a more readable and expressive way to access the last element of an array.
* **Using `for...of` loop**: Instead of indexing or slicing, you can use a `for...of` loop to iterate over the elements of an array and access the last element using `values()`.

It's worth noting that the choice of method ultimately depends on the specific requirements and constraints of your use case.

Related benchmarks:

last array element (version: 0)

get last array element

Comparing performance of: list.slice(-1)[0] vs list[list.length -1]

Created: 4 years ago by: Guest

Jump to the latest result

list.slice(-1)[0]

list[list.length -1]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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