Benchmark: Trimming leading/trailing characters again

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;
}

function splitTrim(str, ch) {
   let res = str.split(ch);
   return res.length > 1 ? res[1] : res[0];
}

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, '+')
Split Version (CheapSk8)
splitTrim(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)
Split Version (CheapSk8)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and its results.

**Benchmark Overview**

The benchmark measures how fast different string trimming functions are executed in JavaScript on a desktop machine running Chrome 120. The test case uses a predefined string `TestString` that contains a mix of characters, including the character `+`, which is used as the trimming character in all test cases.

**Test Cases and Trimming Functions**

There are six test cases:

1. **Index Version (Jason Larke)**: This function uses an index-based approach to trim the string by finding the first and last occurrences of the trimming character and returning the substring between them.
2. **Regex Version (leaf)**: This function uses a regular expression to match the trimming character at the beginning or end of the string and returns the trimmed substring.
3. **Boolean Filter Version (mbaer3000)**: This function splits the string into an array, filters out elements that are equal to the trimming character, and then joins them back together with the trimming character in between.
4. **Spread Version (Robin F.)**: This function uses the spread operator to create a new array with the trimmed characters and then joins them back together with the trimming character in between.
5. **Substring Version (Pho3niX83)**: This function repeatedly removes the trimming character from both ends of the string until only one `+` character remains.
6. **Split Version (CheapSk8)**: This function splits the string into an array using the trimming character and returns the second element (index 1), assuming it's the trimmed substring.

**Results**

The benchmark results show the number of executions per second for each test case on a Chrome 120 browser running on a Windows desktop machine. The top-performing test cases are:

* **Index Version**: approximately 991,832 executions per second
* **Regex Version**: approximately 262,914 executions per second (note: this is relatively slow compared to the index version)
* **Spread Version**: approximately 971 executions per second (note: this is relatively slow compared to the other test cases)

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **Index Version**: Fast, simple, and efficient, but may not be as effective for strings with multiple occurrences of the trimming character.
2. **Regex Version**: Relatively slow due to the overhead of regular expression parsing and matching, but can handle strings with multiple occurrences of the trimming character.
3. **Boolean Filter Version**: Slow due to the unnecessary creation of an array and filtering operations, but can be effective for short strings.
4. **Spread Version**: Relatively slow due to the overhead of creating a new array and joining elements, but can be effective for strings with a small number of occurrences of the trimming character.
5. **Substring Version**: Simple and efficient, but may not be as effective for strings with multiple occurrences of the trimming character.
6. **Split Version**: Slow due to the unnecessary splitting operation, which can create many temporary arrays.

**Conclusion**

In summary, the index version is the clear winner in this benchmark, followed closely by the substring version. The regex and spread versions are relatively slower due to their overhead, while the boolean filter version is slow but can be effective for short strings. The split version is the slowest due to its unnecessary splitting operation.

It's worth noting that these results may vary depending on the specific use case and input data.

Latest run results:

Run details: (Test run date: 11 months ago)

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	991832.6 Ops/sec
Regex Version (leaf)	131508.1 Ops/sec
Boolean Filter Version (mbaer3000)	155215.6 Ops/sec
Spread Version (Robin F.)	971.6 Ops/sec
Substring Version (Pho3niX83)	237048.7 Ops/sec
Split Version (CheapSk8)	262914.6 Ops/sec

Related benchmarks:

Trimming leading/trailing characters again (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 Split Version (CheapSk8)

Created: 11 months 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)

Split Version (CheapSk8)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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