Benchmark: Trimming leading/trailing charactersss

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 && ch.indexOf(str[start])>-1)
        ++start;

    while(end > start && ch.indexOf(str[end - 1])>-1)
        --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: 3 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36

Browser/OS: Chrome 92 on Linux

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	65627.2 Ops/sec
Regex Version (leaf)	75848.2 Ops/sec
Boolean Filter Version (mbaer3000)	44504.8 Ops/sec
Spread Version (Robin F.)	2907.5 Ops/sec
Substring Version (Pho3niX83)	142670.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definitions and explain what is being tested.

**Benchmark Definition JSON**

The JSON represents a benchmark definition with several scripts, including `indexTrim`, `regexTrim`, `booleanTrim`, `spreadTrim`, and `substringTrim`. Each script takes two arguments: `str` (the input string) and `ch` (the character to trim).

*   `indexTrim(str, ch)`:
    *   Iterates from the start and end of the string to find occurrences of `ch`.
    *   Returns a new string with all occurrences of `ch` removed.
*   `regexTrim(str, ch)`:
    *   Uses regular expressions to remove all occurrences of `ch` at the start or end of the string.
    *   Special handling for `]`, `^`, and `\\` characters is done by escaping them if necessary.
*   `booleanTrim(str, ch)`:
    *   Splits the input string into an array using `ch` as a separator.
    *   Filters out empty strings from the array using `Boolean`.
    *   Joins the remaining elements back into a string using `ch`.
*   `spreadTrim(str, ch)`:
    *   Finds the first and last occurrences of `ch` in the string using spread syntax.
    *   Returns a new string with all occurrences of `ch` removed between these indices.
*   `substringTrim(str, ch)`:
    *   Removes leading and trailing occurrences of `ch` from the input string.

**Comparison of approaches**

The benchmark tests different approaches to trimming characters from a string:

1.  **Index-based approach**: `indexTrim`
    *   Pros: Efficient for large strings with sparse character distributions.
    *   Cons: Can be slow for strings with many occurrences of the target character.
2.  **Regular expression approach**: `regexTrim`
    *   Pros: Flexible and effective for removing characters at specific positions or patterns.
    *   Cons: May be slower due to regex compilation and matching overhead.
3.  **Boolean filtering approach**: `booleanTrim`
    *   Pros: Simple and easy to implement, suitable for small strings with few occurrences of the target character.
    *   Cons: Inefficient for large strings or sparse character distributions.
4.  **Spread-based approach**: `spreadTrim`
    *   Pros: Fast and efficient for finding first and last occurrences of a character in a string.
    *   Cons: May not be suitable for strings with many occurrences of the target character.
5.  **Substring-based approach**: `substringTrim`
    *   Pros: Simple and easy to implement, suitable for removing leading or trailing characters.
    *   Cons: Inefficient for large strings or sparse character distributions.

**Library usage**

The benchmark uses several libraries:

*   No specific library is mentioned for the standard JavaScript functions (e.g., `Array.prototype.findIndex`, `String.prototype.includes`).
*   However, it's likely that modern browsers and Node.js environments use optimized implementations of these functions under the hood.
*   If a specific library were used (e.g., RegEx or string manipulation libraries), it would be mentioned in the script preparation code.

**Special JS feature or syntax**

The benchmark does not appear to use any special JavaScript features or syntax, such as async/await, arrow functions, or generators.

**Alternatives**

Other alternatives for trimming characters from a string include:

*   Using `Array.prototype.slice()` to create a new array with trimmed elements.
*   Utilizing the `String.prototype.replace()` method with a regex pattern and replacement function.
*   Implementing a custom implementation using bitwise operations or other low-level techniques.

Keep in mind that each approach has its trade-offs, and the best choice depends on the specific requirements of your application.

Related benchmarks:

Trimming leading/trailing charactersss (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: 3 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 2 months ago):