Benchmark: javascript Trimming leading/trailing characters (with set trim)

Script Preparation code:

var TestString = '+'.repeat(200) + '='.repeat(20000) + '+'.repeat(200);

var regexTrim = function(str, ch) {
    if (ch === ']') ch = '\\]';
    else if (ch === '^') ch = '\\^';
    else if (ch === '\\') ch = '\\\\';
    return str.replace(new RegExp('^[' + ch + ']+|[' + ch + ']+$', 'g'), '');
};

function indexTrimSet(str, ch) {
	ch=new Set(ch);	
	for(var end=str.length-1 ; end>=0     && ch.has(str[end  ]) ; --end );
	for(var start=0          ; start<end  && ch.has(str[start]) ; ++start );
	return (start > 0 || end < str.length-1) ? str.substring(start, end+1) : str;
}

function indexTrim(str, ch) {
    var start = 0, 
        end = str.length;

    while(start < end && str[start] === ch)
        ++start;

    while(end > start && str[end - 1] === ch)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

function booleanTrim(str, ch) {
    return str.split(ch).filter(Boolean).join(ch);
}

function spreadTrim(str, ch) {
    const first = [...str].findIndex(char => char !== ch);
    const last = [...str].reverse().findIndex(char => char !== ch);
    return str.substring(first, str.length - last);
}

function substringTrim(str, ch) {
    while(str.charAt(0)==ch) {
        str = str.substring(1);
    }

    while(str.charAt(str.length-1)==ch) {
        str = str.substring(0,str.length-1);
    }

    return str;
}

Tests:

Index Version (Jason Larke)
indexTrim(TestString, '+');
Regex Version (leaf)
regexTrim(TestString, '+')
Boolean Filter Version (mbaer3000)
booleanTrim(TestString, '+')
Spread Version (Robin F.)
spreadTrim(TestString, '+')
Substring Version (Pho3niX83)
substringTrim(TestString, '+')
set version of indexTrim optimized for trimming many different characters
indexTrimSet(TestString, '+')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Index Version (Jason Larke)
Regex Version (leaf)
Boolean Filter Version (mbaer3000)
Spread Version (Robin F.)
Substring Version (Pho3niX83)
set version of indexTrim optimized for trimming many different characters

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	729295.2 Ops/sec
Regex Version (leaf)	120628.1 Ops/sec
Boolean Filter Version (mbaer3000)	157252.7 Ops/sec
Spread Version (Robin F.)	4886.4 Ops/sec
Substring Version (Pho3niX83)	238000.8 Ops/sec
set version of indexTrim optimized for trimming many different characters	311734.7 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests various approaches for trimming leading and trailing characters from a string in JavaScript. The string being tested, `TestString`, consists of 200 '+' characters, followed by 20,000 '=' characters, and additional 200 '+' characters.

### Overview of the Tests

The benchmark includes six different trimming techniques, each with its own approach and efficiency characteristics:

1. **Index Trim (indexTrim)**:
   - **Description**: Uses a two-pointer technique that identifies the first and last non-target character indexes and slices the string accordingly.
   - **Pros**: Efficient for a single character as it only requires two scans (one from the left and one from the right).
   - **Cons**: Less efficient for scenarios where a large set of characters needs to be trimmed.

2. **Regular Expression Trim (regexTrim)**:
   - **Description**: Utilizes a regular expression to match and replace leading and trailing characters.
   - **Pros**: Concise and flexible, capable of trimming multiple characters in a single expression.
   - **Cons**: Can be slower than direct string manipulation methods due to the overhead of regex processing.

3. **Boolean Filter Trim (booleanTrim)**:
   - **Description**: Splits the string by the target character and filters out empty results before joining them back.
   - **Pros**: Simple and supports trimming multiple characters very easily.
   - **Cons**: Can be less performant due to the array creation and manipulation overhead.

4. **Spread Trim (spreadTrim)**:
   - **Description**: Converts the string into an array (via spread operator), finds the first and last non-target character, and creates a substring.
   - **Pros**: Simple logic using modern JavaScript features.
   - **Cons**: The conversion to an array incurs overhead; may result in lower performance.

5. **Substring Trim (substringTrim)**:
   - **Description**: A direct approach that repeatedly removes characters from both ends of the string until a non-target character is found.
   - **Pros**: Straightforward and clear logic.
   - **Cons**: Potentially slower due to repeated string slicing, especially for longer strings.

6. **Set Optimized Index Trim (indexTrimSet)**:
   - **Description**: Similar to indexTrim but uses a `Set` for checking if a character should be trimmed, allowing multiple characters to be removed efficiently.
   - **Pros**: Effective for trimming multiple characters while maintaining performance benefits of the two-pointer approach.
   - **Cons**: There is a small overhead in creating a Set, but this is negligible compared to its performance gains.

### Benchmark Results Summary

The results show how many times each trimming method executed per second (ExecutionsPerSecond) on Chrome 130 desktop. The performance of the methods varies significantly:

- **Fastest**: The `Index Trim` scored approximately 729,295 executions per second.
- **Slowest**: The `Spread Trim` scored only about 4,886 executions per second, indicating substantial performance overhead due to the array conversion.

### Other Considerations

- **Browser and Environment**: The benchmarks take place in the context of Chrome 130 on a Windows desktop. Performance can vary across different browsers and operating systems.
- **Use Cases**: The method one chooses for trimming should be based on the specific use case. For trimming a single character, methods like `indexTrim` are optimal, while `regexTrim` and `booleanTrim` are more suited to cases where multiple distinct characters need to be trimmed.

### Alternatives

In addition to the above techniques, alternatives for string trimming in JavaScript could include:
- **Native `String.prototype.trim()`**: This method only trims whitespace from both sides of a string and does not support trimming specific characters.
- **Third-party libraries**: Libraries like Lodash offer utility functions that can simplify complex operations, including string manipulations. However, adopting such a library often comes with additional overhead because of bundle size and maintaining dependencies.

When selecting a trimming method, consider not only performance but also readability and maintainability of the code, especially in a collaborative environment where various engineers will interact with the code.

Related benchmarks:

javascript Trimming leading/trailing characters (with set trim) (version: 1)

Comparing performance of: Index Version (Jason Larke) vs Regex Version (leaf) vs Boolean Filter Version (mbaer3000) vs Spread Version (Robin F.) vs Substring Version (Pho3niX83) vs set version of indexTrim optimized for trimming many different characters

Created: 12 days ago by: Guest

Jump to the latest result

Index Version (Jason Larke)

Regex Version (leaf)

Boolean Filter Version (mbaer3000)

Spread Version (Robin F.)

Substring Version (Pho3niX83)

set version of indexTrim optimized for trimming many different characters

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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