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

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 44 runs

Index Version (Jason Larke)

983K/s

Substring Version (Pho3niX83)

316K/s

Boolean Filter Version (mbaer3000)

155K/s

Regex Version (leaf)

135K/s

Spread Version (Robin F.)

4K/s

Fastest: Index Version (Jason Larke) (229.6x faster)

View exact numbers

✓ Index Version (Jason Larke): 982,518 ops/sec
• Substring Version (Pho3niX83): 316,193 ops/sec
• Boolean Filter Version (mbaer3000): 155,428 ops/sec
• Regex Version (leaf): 134,839 ops/sec
• Spread Version (Robin F.): 4,280 ops/sec

Firefox 15 runs

Index Version (Jason Larke)

746K/s

Substring Version (Pho3niX83)

261K/s

Regex Version (leaf)

99K/s

Boolean Filter Version (mbaer3000)

56K/s

Spread Version (Robin F.)

2K/s

Fastest: Index Version (Jason Larke) (299.2x faster)

View exact numbers

✓ Index Version (Jason Larke): 746,093 ops/sec
• Substring Version (Pho3niX83): 261,278 ops/sec
• Regex Version (leaf): 98,732 ops/sec
• Boolean Filter Version (mbaer3000): 55,580 ops/sec
• Spread Version (Robin F.): 2,493 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 20 hours ago)

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

Browser/OS: Chrome 150 on Windows

View result in a separate tab

Index Version (Jason Larke)

1.7M/s

Substring Version (Pho3niX83)

660K/s

Boolean Filter Version (mbaer3000)

332K/s

Regex Version (leaf)

129K/s

Spread Version (Robin F.)

7K/s

View exact numbers

Test name	Executions per second
✓ Index Version (Jason Larke)	1,682,184 Ops/sec
Substring Version (Pho3niX83)	660,013 Ops/sec
Boolean Filter Version (mbaer3000)	331,840 Ops/sec
Regex Version (leaf)	129,340 Ops/sec
Spread Version (Robin F.)	7,252 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 5 years ago by: Guest

Go to the latest result

Index Version (Jason Larke)

Regex Version (leaf)

Boolean Filter Version (mbaer3000)

Spread Version (Robin F.)

Substring Version (Pho3niX83)

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 44 runs

Firefox 15 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

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: 5 years ago by: Guest

Go to the latest result

Index Version (Jason Larke)

Regex Version (leaf)

Boolean Filter Version (mbaer3000)

Spread Version (Robin F.)

Substring Version (Pho3niX83)

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 44 runs

Firefox 15 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

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