Benchmark: String reversal 3

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)].join('')
Array.of
for(let i = 300; i--;)var t = Array.of(...string).toReversed().join('')
Array
for(let i = 300; i--;)var t = Array(...string).toReversed().join('')
split
for(let i = 300; i--;)var t = string.split('').toReversed().join('')

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*
Array.of
Array
split

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	1068.2 Ops/sec
Array.from+toReversed+join	1141.3 Ops/sec
toReversed.call+join	341.2 Ops/sec
backwards function*	407.8 Ops/sec
Array.of	421.3 Ops/sec
Array	474.7 Ops/sec
split	1328.8 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark tests various methods of reversing a string in JavaScript. The focus is on how different approaches in JavaScript yield performance differences when reversing a string of fixed length (50 characters). Here, we will dissect each method tested and evaluate their advantages and disadvantages.

### Benchmark Options Explained

1. **spread + toReversed + join**  
   **Code:** `for(let i = 300; i--;)var t = [...string].toReversed().join('')`  
   **Pros:** This method utilizes the spread operator to convert the string into an array and then uses the proposed `toReversed()` function, which returns a new array with elements in reverse order.  
   **Cons:** The usage of the spread operator entails creating a new array, which has overhead in terms of memory and performance.

2. **Array.from + toReversed + join**  
   **Code:** `for(let i = 300; i--;)var t = Array.from(string).toReversed().join('')`  
   **Pros:** `Array.from` is explicit in converting the iterable (string) into an array, subsequently allowing for `toReversed()`.  
   **Cons:** Similar to the first method, this also requires memory allocation for the new array.

3. **toReversed.call + join**  
   **Code:** `for(let i = 300; i--;)var t = [].toReversed.call(string).join('')`  
   **Pros:** This approach uses `Function.prototype.call` to invoke `toReversed` on the string as if it were an array.  
   **Cons:** This can be less intuitive and may lead to performance issues compared to other more direct methods.

4. **backwards function***  
   **Code:** `for(let i = 300; i--;)var t = [...backwards(string)].join('')`  
   **Pros:** It implements a generator function to iterate over the string in reverse. This might be memory efficient if lazy evaluation is preferred.  
   **Cons:** Running a generator can incur some overhead due to function calls and requires generating the array from the generator's output.

5. **Array.of**  
   **Code:** `for(let i = 300; i--;)var t = Array.of(...string).toReversed().join('')`  
   **Pros:** `Array.of` creates an array from the string using the spread syntax, and it also offers cleaner syntax than `Array()` or `Array.from()`.  
   **Cons:** Again, it has a memory allocation footprint similar to the others that require an array.

6. **Array**  
   **Code:** `for(let i = 300; i--;)var t = Array(...string).toReversed().join('')`  
   **Pros:** Constructs an array using the string with spread syntax. It's straightforward and functional.  
   **Cons:** Like other methods, it creates an intermediary array, incurring performance costs.

7. **split**  
   **Code:** `for(let i = 300; i--;)var t = string.split('').toReversed().join('')`  
   **Pros:** `split('')` breaks the string into an array of characters quickly. Paired with `toReversed()`, it's quite efficient.  
   **Cons:** It will create an additional array but is widely known and used, making it intuitive.

### Comparative Analysis:

From the benchmark results, the `split` method outperformed others (1328.81 executions per second), followed closely by `Array.from + toReversed + join` (1141.25 executions per second) and the `spread + toReversed + join` (1068.22 executions per second). The methods employing the generator function and the `toReversed.call` resulted in the lowest executions per second.

### Alternative Methods

There are additional ways to reverse strings that could be considered:

1. **Manual Looping**: Implementing a simple `for` loop to construct the reversed string character by character.
   ```javascript
   function reverseString(str) {
       let reversed = '';
       for (let i = str.length - 1; i >= 0; i--) {
           reversed += str[i];
       }
       return reversed;
   }
   ```
   - **Pros:** Direct manipulative access avoids overhead from creating arrays.
   - **Cons:** Might be less readable compared to existing higher-level methods.

2. **Recursion**: Using a recursive approach to reverse the string.
   ```javascript
   function reverseString(str) {
       return str === '' ? '' : reverseString(str.substr(1)) + str.charAt(0);
   }
   ```
   - **Pros:** Elegant and concise syntax.
   - **Cons:** Could hit recursion limits for long strings and generally will have worse performance.

In conclusion, the benchmark highlights the importance of choosing the right approach for string manipulation in JavaScript, weighing performance against readability and ease of implementation.

Related benchmarks:

String reversal 3 (version: 1)

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

Created: 4 days ago by: Guest

Jump to the latest result

spread+toReversed+join

Array.from+toReversed+join

toReversed.call+join

backwards function*

Array.of

Array

split

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