Benchmark: Trimming leading/trailing characterss

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,
        chList = [...ch];

    while(start < end && chList.includes(str[start]))
        ++start;

    while(end > start && chList.includes(str[end - 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;
}

​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,        chList = [...ch];​    while(start < end && chList.includes(str[start]))        ++start;​    while(end > start && chList.includes(str[end - 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, '+');
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, '+')

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)

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)	167225.4 Ops/sec
Regex Version (leaf)	75542.3 Ops/sec
Boolean Filter Version (mbaer3000)	44754.6 Ops/sec
Spread Version (Robin F.)	2925.8 Ops/sec
Substring Version (Pho3niX83)	145031.4 Ops/sec

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

Benchmark Overview

The provided benchmark measures the performance of four different trimming algorithms for leading and trailing characters in a string:

indexTrim: Uses a simple iterative approach to find and remove leading/trailing characters.
regexTrim: Utilizes regular expressions to match and replace leading/trailing characters.
booleanTrim: Employs the split() method followed by filtering out empty strings using Boolean.
spreadTrim: Uses the spread operator (...) to find the first and last occurrence of a character, then removes them from the string.

Options Compared

The benchmark compares the performance of each algorithm across various browsers (Chrome 92) on different devices (Desktop).

Pros and Cons of Each Approach

indexTrim:
- Pros: Simple, easy to understand, and potentially efficient for small strings.
- Cons: May not be optimized for larger strings or edge cases.
regexTrim:
- Pros: Flexible and effective for matching specific patterns, but can be slower due to the overhead of regular expressions.
- Cons: May have performance issues with complex patterns or very large strings.
booleanTrim:
- Pros: Simple and efficient, as it leverages the split() method and filtering out empty strings.
- Cons: May not be suitable for strings with only one character to trim.
spreadTrim:
- Pros: Potentially efficient for large strings, as it avoids iterating over the entire string.
- Cons: May have performance issues if the first or last occurrence of a character is rare.

Library Used

None of the provided code snippets use external libraries. However, some browsers may have built-in optimizations or features that could affect the performance of these algorithms (e.g., Chrome's String.prototype.trim() method uses regular expressions under the hood).

Special JS Features/Syntax

The benchmark does not utilize any special JavaScript features or syntax beyond what is standard in ECMAScript 2020.

Alternatives

Other trimming algorithms or approaches could be explored, such as:

Using String.prototype.replaceAll() with a replacement string of an empty character.
Leveraging a library like Lodash's trim function.
Implementing a custom trimming algorithm using bitwise operations (e.g., checking the first and last characters of the string).

Keep in mind that these alternatives may have different performance characteristics, trade-offs, or even be less suitable for certain use cases.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of four different trimming algorithms for leading and trailing characters in a string:

1. `indexTrim`: Uses a simple iterative approach to find and remove leading/trailing characters.
2. `regexTrim`: Utilizes regular expressions to match and replace leading/trailing characters.
3. `booleanTrim`: Employs the `split()` method followed by filtering out empty strings using `Boolean`.
4. `spreadTrim`: Uses the spread operator (`...`) to find the first and last occurrence of a character, then removes them from the string.

**Options Compared**

The benchmark compares the performance of each algorithm across various browsers (Chrome 92) on different devices (Desktop).

**Pros and Cons of Each Approach**

1. `indexTrim`:
	* Pros: Simple, easy to understand, and potentially efficient for small strings.
	* Cons: May not be optimized for larger strings or edge cases.
2. `regexTrim`:
	* Pros: Flexible and effective for matching specific patterns, but can be slower due to the overhead of regular expressions.
	* Cons: May have performance issues with complex patterns or very large strings.
3. `booleanTrim`:
	* Pros: Simple and efficient, as it leverages the `split()` method and filtering out empty strings.
	* Cons: May not be suitable for strings with only one character to trim.
4. `spreadTrim`:
	* Pros: Potentially efficient for large strings, as it avoids iterating over the entire string.
	* Cons: May have performance issues if the first or last occurrence of a character is rare.

**Library Used**

None of the provided code snippets use external libraries. However, some browsers may have built-in optimizations or features that could affect the performance of these algorithms (e.g., Chrome's `String.prototype.trim()` method uses regular expressions under the hood).

**Special JS Features/Syntax**

The benchmark does not utilize any special JavaScript features or syntax beyond what is standard in ECMAScript 2020.

**Alternatives**

Other trimming algorithms or approaches could be explored, such as:

1. Using `String.prototype.replaceAll()` with a replacement string of an empty character.
2. Leveraging a library like Lodash's `trim` function.
3. Implementing a custom trimming algorithm using bitwise operations (e.g., checking the first and last characters of the string).

Keep in mind that these alternatives may have different performance characteristics, trade-offs, or even be less suitable for certain use cases.

Related benchmarks:

Trimming leading/trailing characterss (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 4 months ago):