Benchmark: Array last item - MeasureThat.net

Tests:

Spread, reverse, destructure
const items = new Array(5000).fill(null).map((_, i) => i); for(let i=0; i<10000; ++i){ let [last] = [...items].reverse(); }
Access by length - 1
const items = new Array(5000).fill(null).map((_, i) => i); for(let i=0; i<10000; ++i){ let last = items[items.length - 1]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Spread, reverse, destructure
Access by length - 1

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
Spread, reverse, destructure	0.2 Ops/sec
Access by length - 1	35562.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark is designed to measure the performance of accessing an element at the end of an array in JavaScript. The test creates two different scenarios:

1. "Access by length - 1": This test accesses the last element of an array using indexing (e.g., `items[items.length - 1]`).
2. "Spread, reverse, destructure": This test uses a more complex approach: it first reverses the array and then destructures the last element using the spread operator (e.g., `[...items].reverse(); let [last] = [...items];`).

**Options Compared**

The benchmark compares two different approaches to accessing an element at the end of an array:

1. **Indexing**: Using the `[]` notation to access the last element of an array.
2. **Spread and reverse**: Reversing the array using the spread operator (`[...items]`) and then destructuring the last element.

**Pros and Cons**

* **Indexing (Access by length - 1)**:
	+ Pros: Simple, efficient, and widely supported.
	+ Cons: May not be as readable or maintainable, especially for larger arrays.
* **Spread and reverse (Spread, reverse, destructure)**:
	+ Pros: Can be more expressive and readable, especially for complex operations.
	+ Cons: May be slower due to the additional operations involved (reversing the array).

**Other Considerations**

In addition to these two approaches, other methods can also be used to access an element at the end of an array, such as:

* Using `Array.prototype.at()` (if supported by the browser)
* Creating a custom function or method for accessing the last element

However, these alternatives are not explicitly tested in this benchmark.

**Library Usage**

None of the test cases use any external libraries. The tests rely solely on native JavaScript features.

**Special JS Features or Syntax**

The benchmark uses several advanced JavaScript features:

* Destructuring assignment (e.g., `let [last] = [...items];`)
* Spread operator (`[...items]`)
* Reverse iteration using `[...items].reverse()`

Related benchmarks:

Array last item (version: 0)

Comparing performance of: Spread, reverse, destructure vs Access by length - 1

Created: 3 years ago by: Guest

Jump to the latest result

Spread, reverse, destructure

Access by 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):