Benchmark: reverse vs map vs toReversed

Script Preparation code:

test = Array(1000).fill().map((_,i) => i);

Tests:

ES Reverse / in place
test.reverse()
ES map
[...test].map(test.pop, test)
ES toReversed
test.toReversed()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ES Reverse / in place
ES map
ES toReversed

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
ES Reverse / in place	1503817.4 Ops/sec
ES map	4001352.2 Ops/sec
ES toReversed	11545549.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition JSON**

The benchmark definition JSON provides essential information about the test case:

* `Name`: The name of the benchmark, which is "reverse vs map vs toReversed" in this case.
* `Description`: No description is provided for this benchmark.
* `Script Preparation Code`: This code is executed before running the benchmark. It creates an array of 1000 elements filled with ascending integers from 0 to 999 (`test = Array(1000).fill().map((_,i) => i);`).
* `Html Preparation Code`: No HTML preparation code is provided.

**Individual Test Cases**

The test cases are defined as a JSON array, each representing a different approach to reversing the array:

1. **ES Reverse / in place**: This test case uses the `reverse()` method to reverse the array in-place.
2. **ES map**: This test case uses the `map()` method with a custom callback function that calls `pop()` on the original array, effectively reversing it.
3. **ES toReversed**: This test case uses an implementation-specific method called `toReversed()`, which is not defined in standard JavaScript.

**Comparison of Approaches**

Let's analyze each approach:

* **ES Reverse / in place**: This approach modifies the original array and returns `undefined`. It's a simple and efficient way to reverse an array.
	+ Pros:
		- Fast execution
		- Modifies the original array (no extra memory allocation)
	+ Cons:
		- Returns `undefined`
		- May not be as intuitive for some developers
* **ES map**: This approach uses the `map()` method with a custom callback function to create a new reversed array.
	+ Pros:
		- Creates a new reversed array without modifying the original one
		- More intuitive for some developers due to its use of `map()`
	+ Cons:
		- Requires an extra memory allocation (creating a new array)
		- Slower execution compared to the in-place approach
* **ES toReversed**: This approach uses an implementation-specific method that reverses the array.
	+ Pros:
		- May be more intuitive for developers familiar with this method
	+ Cons:
		- Implementation details are not part of standard JavaScript (not portable)
		- Execution speed is unclear without knowing how it's implemented

**Library: Lodash**

The `map()` function used in the "ES map" test case is from the popular utility library Lodash. Lodash provides a convenient and consistent way to perform common tasks, such as array manipulation.

**Other Considerations**

When running benchmarks, consider factors like:

* **Memory allocation**: How does each approach allocate memory? In-place modifications can be beneficial for performance.
* **Cache locality**: Does the execution of each approach exhibit good cache locality?
* **Branch prediction**: Can branch prediction improve or hinder performance?

**Alternatives**

If you want to explore alternative approaches, consider:

* Using `Array.prototype.reverse()`: This is a standard JavaScript method that reverses an array in-place.
* Implementing a custom reversing algorithm using bitwise operations (e.g., shifting elements left and right).
* Utilizing parallel processing or multi-threading to speed up execution.

In conclusion, the choice of approach depends on your specific use case, performance requirements, and personal preference. The benchmark results provided by MeasureThat.net will help you determine which approach is best suited for your needs.

Related benchmarks:

reverse vs map vs toReversed (version: 0)

Comparing performance of: ES Reverse / in place vs ES map vs ES toReversed

Created: 6 months ago by: Guest

Jump to the latest result

ES Reverse / in place

ES map

ES toReversed

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