Benchmark: String reversal - MeasureThat.net

Script Preparation code:

let string = Array.from({
    length: 50
}, (_, index) => index).join('')

function* backwards(iterable) {
    for (let {
            length
        } = iterable; length--;) yield iterable[length]
}

Tests:

spread+toReversed+join
for(let i = 300; i--;)var t = [...string].toReversed().join('')
Array.from+toReversed+join
for(let i = 300; i--;)var t = Array.from(string).toReversed().join('')
toReversed.call+join
for(let i = 300; i--;)var t = [].toReversed.call(string).join('')
backwards function*
for(let i = 300; i--;)var t = [...backwards(string)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread+toReversed+join
Array.from+toReversed+join
toReversed.call+join
backwards function*

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Chrome OS 14541.0.0

View result in a separate tab

Test name	Executions per second
spread+toReversed+join	1121.9 Ops/sec
Array.from+toReversed+join	1129.1 Ops/sec
toReversed.call+join	345.3 Ops/sec
backwards function*	586.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 days ago):

LLMs can make mistakes. Check important info.

The benchmark is focused on testing the performance of different methods for reversing a string in JavaScript. It compares several approaches to achieve this, including the use of built-in methods, a custom generator function, and different ways to handle string data. Below is a description of the various options compared, their pros and cons, and considerations for using these methods.

### Options Compared

1. **Spread Operator with `toReversed` and `join`:**
   - **Benchmark Definition:** `for(let i = 300; i--;)var t = [...string].toReversed().join('')`
   - **Test Name:** "spread+toReversed+join"
   - **Performance:** 1129.06 executions per second.
   
   **Pros:**
   - The spread operator (`[...]`) is concise and easy to read.
   - `toReversed()` is a built-in method designed to reverse arrays or strings, ensuring optimal performance.

**Cons:**
   - The spread operator creates a new array, which can consume additional memory if the string is large.

2. **Array.from with `toReversed` and `join`:**
   - **Benchmark Definition:** `for(let i = 300; i--;)var t = Array.from(string).toReversed().join('')`
   - **Test Name:** "Array.from+toReversed+join"
   - **Performance:** 1121.89 executions per second.
   
   **Pros:**
   - `Array.from()` is a versatile method for creating arrays from array-like objects, such as strings.
   - It integrates well with `toReversed()` for direct string-to-reversal functionality.
   
   **Cons:**
   - Similar to the spread operator, this method also creates an intermediate array, which could be less memory-efficient.

3. **Using `toReversed` through `call`:**
   - **Benchmark Definition:** `for(let i = 300; i--;)var t = [].toReversed.call(string).join('')`
   - **Test Name:** "toReversed.call+join"
   - **Performance:** 345.32 executions per second.
   
   **Pros:**
   - This method allows for flexible handling of the `toReversed()` function's context, potentially useful for dynamic use cases.
   
   **Cons:**
   - It has the poorest performance in this benchmark, revealing overhead due to method binding and the way `call()` operates.
   - The readability may suffer as it deviates from standard string manipulation practices.

4. **Custom Generator Function:**
   - **Benchmark Definition:** `for(let i = 300; i--;)var t = [...backwards(string)]`
   - **Test Name:** "backwards function*"
   - **Performance:** 586.11 executions per second.
   
   **Pros:**
   - The generator function (`function* backwards`) provides a clear and structured way to iterate through the string in reverse without intermediate array creation.
   - It offers flexibility and could be extended or modified easily.
   
   **Cons:**
   - While it avoids creating multiple temporary arrays, the overall performance is lower, indicating that manual iteration may not be as optimized as built-in methods for large datasets.
   - It also has a higher complexity due to its function invocation overhead.

### Other Considerations
- **Performance Variance:** As seen in the results, methods utilizing built-in functions (`toReversed()`) perform better than custom implementations. This highlights the efficiency of native methods in modern JavaScript engines.
- **Memory Usage:** While performance is critical, memory consumption should also be a consideration when working with larger strings or data sets.
- **Code Readability and Maintainability:** The choice of method can also affect how easily other developers can understand and maintain the code. Approaches utilizing standard JS array methods generally enhance clarity.

### Alternatives
- Other alternatives could include using `reduce()`, `for` loops, or recursive functions for reversing strings, albeit with lower performance and possible readability trade-offs compared to the modern methods tested here.

In summary, each method offers unique benefits and trade-offs, with built-in functions often being preferable for performance and readability. While all approaches achieve the desired result of string reversal, the decision on which to use should consider both execution speed and the clarity of the code.

Related benchmarks:

String reversal (version: 1)

Comparing performance of: spread+toReversed+join vs Array.from+toReversed+join vs toReversed.call+join vs backwards function*

Created: 4 days ago by: Guest

Jump to the latest result

spread+toReversed+join

Array.from+toReversed+join

toReversed.call+join

backwards function*

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 days ago):