Benchmark: Trimming leading/trailing characters Bounds Fix

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 indexTrimB(str, ch) {
    var start = 0, 
        end = str.length - 1;

    while(start <= end && str[start] === ch)
        ++start;

    while(end >= start && str[end] === ch)
        --end;

    return (start > 0 || end < str.length - 1) ? 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, '+')
Index Version (Jason Larke) B
indexTrimB(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)
Index Version (Jason Larke) B

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark definition and explain what's being tested, along with the pros and cons of each approach.

**Benchmark Definition:**

The benchmark tests four different implementations of string trimming:

1. `indexTrim(str, ch)`
2. `regexTrim(str, ch)`
3. `booleanTrim(str, ch)`
4. `spreadTrim(str, ch)`
5. `substringTrim(str, ch)`

These functions aim to remove leading and trailing occurrences of a specified character `ch` from a string `str`.

**Options Compared:**

The benchmark compares the performance of each implementation across different browsers, devices, and operating systems.

**Pros and Cons of Each Approach:**

1. **indexTrim(str, ch)**:
	* Pros: Simple, straightforward implementation.
	* Cons: May not work correctly with edge cases (e.g., empty strings or null inputs).
2. **regexTrim(str, ch)**:
	* Pros: Robust and flexible, can handle edge cases and complex regular expressions.
	* Cons: May be slower due to the overhead of regular expression parsing and execution.
3. **booleanTrim(str, ch)**:
	* Pros: Easy to implement and understand.
	* Cons: May not work correctly with certain characters (e.g., whitespace or punctuation).
4. **spreadTrim(str, ch)**:
	* Pros: Efficient use of built-in `findIndex` and `substring` methods.
	* Cons: May be less intuitive for developers without experience with these methods.
5. **substringTrim(str, ch)**:
	* Pros: Simple and efficient implementation using substring manipulation.
	* Cons: May not work correctly with edge cases (e.g., strings with only one character).

**Library Used:**

The `booleanTrim` function uses the `split`, `filter`, and `join` methods from JavaScript's built-in String API. These methods are part of the ECMAScript Standard, so they're widely supported across browsers.

**Special JS Feature or Syntax:**

None of the functions in this benchmark utilize any special JavaScript features or syntax beyond standard ECMAScript functionality.

**Other Considerations:**

* The benchmark uses a large input string (`TestString`) to simulate real-world scenarios and ensure that each implementation is thoroughly tested.
* The test cases cover various browser versions, devices, and operating systems to ensure compatibility and performance consistency.

In conclusion, this benchmark provides a comprehensive comparison of different string trimming implementations in JavaScript, highlighting their strengths and weaknesses. By analyzing the results, developers can choose the most suitable approach for their specific use case, taking into account factors like performance, simplicity, and edge case handling.

Related benchmarks:

Trimming leading/trailing characters Bounds Fix (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) vs Index Version (Jason Larke) B

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)

Index Version (Jason Larke) B

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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