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;
}

​x
 
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, '+');
indexTrim(TestString, '+');
Regex Version (leaf)
regexTrim(TestString, '+')
regexTrim(TestString, '+')
Boolean Filter Version (mbaer3000)
booleanTrim(TestString, '+')
booleanTrim(TestString, '+')
Spread Version (Robin F.)
spreadTrim(TestString, '+')
spreadTrim(TestString, '+')
Substring Version (Pho3niX83)
substringTrim(TestString, '+')
substringTrim(TestString, '+')
Index Version (Jason Larke) B
indexTrimB(TestString, '+');
indexTrimB(TestString, '+');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	551615.7 Ops/sec
Regex Version (leaf)	73931.5 Ops/sec
Boolean Filter Version (mbaer3000)	91273.3 Ops/sec
Spread Version (Robin F.)	3871.1 Ops/sec
Substring Version (Pho3niX83)	234902.2 Ops/sec
Index Version (Jason Larke) B	658822.9 Ops/sec

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

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:

indexTrim(str, ch)
regexTrim(str, ch)
booleanTrim(str, ch)
spreadTrim(str, ch)
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:

indexTrim(str, ch):
- Pros: Simple, straightforward implementation.
- Cons: May not work correctly with edge cases (e.g., empty strings or null inputs).
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.
booleanTrim(str, ch):
- Pros: Easy to implement and understand.
- Cons: May not work correctly with certain characters (e.g., whitespace or punctuation).
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.
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.

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.

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

Index Version (Jason Larke) B

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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