Benchmark: Trimming leading/trailing characters

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 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, '+')

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)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	1244191.1 Ops/sec
Regex Version (leaf)	110652.0 Ops/sec
Boolean Filter Version (mbaer3000)	238984.9 Ops/sec
Spread Version (Robin F.)	5266.5 Ops/sec
Substring Version (Pho3niX83)	365677.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents a benchmark definition for trimming leading and trailing characters from a string. The script preparation code defines four functions: `indexTrim`, `regexTrim`, `booleanTrim`, and `spreadTrim`. Each function implements a different approach to trim the string:

1.  **Index Version (Jason Larke)**: This function uses two pointers (`start` and `end`) to identify the first and last occurrences of the character in question (`ch`). It then returns the substring from `start + 1` to `end - 1`.
2.  **Regex Version (leaf)**: This function uses a regular expression to match the leading or trailing characters (`^` or `$`) followed by any amount of additional characters. The `replace()` method removes these matches.
3.  **Boolean Filter Version (mbaer3000)**: This function splits the string into an array using the character as a separator and then filters out empty strings, effectively removing leading/trailing whitespace.
4.  **Spread Version (Robin F.)**: This function finds the first and last occurrences of the character in the reversed string and uses that to create the trimmed substring.

**Options Compared**

The benchmark compares the performance of these four trimming approaches across different browsers (Chrome 129) on a desktop platform running Mac OS X 10.15.7.

**Pros and Cons**

Here's a brief overview of each approach:

*   **Index Version**: Pros: Simple, efficient, and easy to understand. Cons: May not work well with non-ASCII characters or edge cases.
*   **Regex Version**: Pros: Flexible, handles most character types. Cons: Can be slow for large strings due to the overhead of regular expressions.
*   **Boolean Filter Version**: Pros: Easy to implement, works well with whitespace. Cons: May not handle other characters correctly and can result in slower performance compared to regex.
*   **Spread Version**: Pros: Simple and efficient for trimming substrings. Cons: Only suitable for trimming single character substrings.

**Other Considerations**

When choosing a trimming approach, consider the specific requirements of your use case:

*   If you need to handle non-ASCII characters or edge cases, `Regex Version` might be more suitable.
*   For simple trimming tasks with whitespace, `Boolean Filter Version` could be sufficient.
*   When working with substrings, `Spread Version` can be a good choice.

**Libraries and Features**

No special JavaScript libraries are required for this benchmark. However, the use of Unicode characters (`+`, `\]`, `^`, etc.) requires support for Unicode in the browser or environment.

There are no special JavaScript features like ES6 syntax, async/await, or Promises explicitly mentioned in the provided code.

Now you should have a better understanding of the benchmark's test cases and trimming approaches.

Related benchmarks:

Trimming leading/trailing characters (version: 0)

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)

Created: 4 years 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)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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