Benchmark: Array reverse - MeasureThat.net

Script Preparation code:

var test = ["a", "b", "c", "d", "e"];

Tests:

Reverse (unmodified)
test.slice().reverse()
Reverse (modified)
test.reverse()
Map reverse
var max = test.length - 1; test.map((a,index,list) => list[max - index])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reverse (unmodified)
Reverse (modified)
Map reverse

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the provided benchmark and its different approaches.

**What is being tested?**

The provided benchmark tests the execution speed of three different methods for reversing an array in JavaScript:

1. **`test.slice().reverse()`**: This method creates a shallow copy of the original array using `slice()`, and then reverses the copied array using `reverse()`.
2. **`test.reverse()`**: This method modifies the original array by reversing its elements in place.
3. **`var max = test.length - 1; test.map((a, index, list) => list[max - index])`**: This method uses a combination of variables and the `map()` function to create a new array with the reversed order of elements.

**Options compared**

The three approaches are being compared in terms of their execution speed. The benchmark measures the number of executions per second for each approach on a given machine.

**Pros and cons of each approach:**

1. **`test.slice().reverse()`**: This approach is safe to use, as it creates a shallow copy of the original array without modifying its contents. However, it can be slower than other approaches since it involves creating an additional array.
	* Pros: Safe, easy to understand and implement.
	* Cons: Can be slower due to extra memory allocation.
2. **`test.reverse()`**: This approach modifies the original array in place, which can lead to unexpected side effects if used in a larger program. However, it is generally faster than other approaches since it only involves modifying the existing array.
	* Pros: Fastest execution time.
	* Cons: May be considered unsafe or unpredictable due to potential side effects.
3. **`var max = test.length - 1; test.map((a, index, list) => list[max - index])`**: This approach uses a combination of variables and the `map()` function to create a new array with the reversed order of elements.
	* Pros: Can be more efficient than other approaches since it only involves modifying an existing array.
	* Cons: May require additional variables and can be harder to understand for some developers.

**Library used**

None of the provided benchmark definitions use any external libraries beyond JavaScript's built-in `slice()` and `reverse()` methods, as well as the `map()` function.

**Special JS feature or syntax**

The benchmark does not use any special JavaScript features or syntax, such as async/await, promises, or modern ECMAScript syntax (e.g., arrow functions, template literals).

**Other alternatives**

If you wanted to test other approaches for reversing an array in JavaScript, some additional methods might include:

* Using a library like Lodash's `reverse()` method.
* Implementing a custom recursive function to reverse the array.
* Using a streaming algorithm to reverse the array without creating an intermediate array.

However, the three provided approaches (`slice().reverse()`, `reverse()`, and `map()` with indices) are among the most common and efficient ways to reverse an array in JavaScript.

Latest run results:

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

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Reverse (unmodified)	8194506.5 Ops/sec
Reverse (modified)	10065611.0 Ops/sec
Map reverse	4248384.5 Ops/sec

Related benchmarks:

Array reverse (version: 0)

Comparing performance of: Reverse (unmodified) vs Reverse (modified) vs Map reverse

Created: one year ago by: Guest

Jump to the latest result

Reverse (unmodified)

Reverse (modified)

Map reverse

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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