Benchmark: Different method to traverse a reversed array.

Script Preparation code:

const array = Array(10000).fill(0).map((_, i) => i);

Tests:

for loop
let sum = 0; for (let i = array.length - 1; i >= 0; i--) { sum += array[i]; }
for of with reverse
let sum = 0; for (const v of [...array].reverse()) { sum += v; }
for of with toReversed
let sum = 0; for (const v of array.toReversed()) { sum += v; }
reduceRight
const sum = array.reduceRight((prev, curr) => prev + curr, 0);
reduceRight with add operation
let sum = 0; array.reduceRight((_, curr) => { sum += curr; })
forEach with reverse
let sum = 0; [...array].reverse().forEach(v => { sum += v; });
forEach with toReversed
let sum = 0; array.toReversed().forEach(v => { sum += v; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for loop
for of with reverse
for of with toReversed
reduceRight
reduceRight with add operation
forEach with reverse
forEach with toReversed

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
for loop	89871.5 Ops/sec
for of with reverse	74185.2 Ops/sec
for of with toReversed	67183.8 Ops/sec
reduceRight	111826.6 Ops/sec
reduceRight with add operation	52166.2 Ops/sec
forEach with reverse	49967.2 Ops/sec
forEach with toReversed	48362.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined by MeasureThat.net aims to evaluate the performance of different methods for traversing a reversed array in JavaScript. The benchmark is represented by a JSON object and consists of a preparation code that initializes an array of integers from 0 to 9999.

### Test Cases:

1. **For Loop**:
   - Benchmark Definition: 
     ```javascript
     let sum = 0;
     for (let i = array.length - 1; i >= 0; i--) {
       sum += array[i];
     }
     ```
   - **Pros**: This approach is efficient and minimizes memory overhead by directly accessing the array elements in reverse order without creating additional arrays.
   - **Cons**: Not as syntactically clean as other methods, and can be less readable.

2. **For...of with Reverse**:
   - Benchmark Definition:
     ```javascript
     let sum = 0;
     for (const v of [...array].reverse()) {
       sum += v;
     }
     ```
   - **Pros**: This syntax is more modern and readable; it uses the `for...of` loop which is designed for iterable objects.
   - **Cons**: The use of `reverse()` creates a new array, thus increasing memory usage and potentially impacting performance.

3. **For...of with toReversed**:
   - Benchmark Definition:
     ```javascript
     let sum = 0;
     for (const v of array.toReversed()) {
       sum += v;
     }
     ```
   - **Pros**: Similar benefits to using `for...of` while using `toReversed()`, which is a newer JavaScript feature designed for better readability without modifying the original array.
   - **Cons**: Like `reverse()`, `toReversed()` may also create a new array, impacting memory efficiency.

4. **ReduceRight**:
   - Benchmark Definition:
     ```javascript
     const sum = array.reduceRight((prev, curr) => prev + curr, 0);
     ```
   - **Pros**: Leverages higher-order functions, making the code concise and expressive. It is functionally declarative.
   - **Cons**: Might be less performant than simple loops due to the overhead of function calls for every array element.

5. **ReduceRight with Add Operation**:
   - Benchmark Definition:
     ```javascript
     let sum = 0;
     array.reduceRight((_, curr) => {
       sum += curr;
     });
     ```
   - **Pros**: Offers a mechanism similar to `reduceRight` but allows modification of a variable (`sum`) during execution.
   - **Cons**: Similar to the previous `reduceRight`, but potentially less readable.

6. **ForEach with Reverse**:
   - Benchmark Definition:
     ```javascript
     let sum = 0;
     [...array].reverse().forEach(v => {
       sum += v;
     });
     ```
   - **Pros**: Combines a functional approach with a familiar `forEach` syntax. It can be more readable for those used to functional programming styles.
   - **Cons**: Has the same memory overhead as the prior methods using `reverse()`.

7. **ForEach with toReversed**:
   - Benchmark Definition:
     ```javascript
     let sum = 0;
     array.toReversed().forEach(v => {
       sum += v;
     });
     ```
   - **Pros**: Offers readability and functionality while maintaining immutability of the original array.
   - **Cons**: Memory overhead similar to using `reverse()`.

### Benchmark Results:

The benchmark results exhibit the number of executions per second for each method. The greatest performance was observed with the `reduceRight` method, followed by the traditional `for loop`, indicating its efficiency in terms of speed and resource utilization. Other methods that involve reversed or higher-order functions generally fell behind due to additional memory allocations and overhead from function calls.

### General Considerations:

- The choice between these methods often depends on the balance between readability and performance. 
- `for` loops and `reduceRight` tend to perform better for larger datasets due to their adherence to lower-level optimizations.
- The usage of methods like `toReversed()` represents a move toward more semantic and readable code, even if they introduce a performance cost.
- For performance-sensitive applications, solvers often lean towards classical looping constructs unless the readability and expressiveness of modern methods provide significant advantages for the specific use case.

### Alternative Approaches:

Other alternatives could include:
- **While Loop**: A conventional while loop could offer similar performance to the for loop but might be less readable.
- **Using Typed Arrays**: For numeric computations, using typed arrays in JavaScript could yield better performance due to optimizations for numerical data.
- **Web Workers**: For handling larger sets of data in a multi-threaded manner—if performance becomes a bottleneck on the main thread.

The selected approach should align with the needs of the application—prioritizing performance, readability, or a balance of both based on context.

Related benchmarks:

Different method to traverse a reversed array. (version: 1)

Comparing performance of: for loop vs for of with reverse vs for of with toReversed vs reduceRight vs reduceRight with add operation vs forEach with reverse vs forEach with toReversed

Created: 2 months ago by: Registered User

Jump to the latest result

for loop

for of with reverse

for of with toReversed

reduceRight

reduceRight with add operation

forEach with reverse

forEach with toReversed

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):