Benchmark: Trimming leading/trailing characters (short match)

Script Preparation code:

var TestString = '+'.repeat(1) + '='.repeat(20000) + '+'.repeat(1);

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;
}

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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test case that compares different approaches for trimming leading/trailing characters from a string. The main goal is to determine which method is the most efficient.

**Benchmark Definition**

The `Benchmark Definition` json object defines the base benchmark, which includes:

1. **TestString**: A repeating pattern of '+' and '=' characters, with a length of 20,001.
2. **regexTrim**: A regular expression-based function that removes leading/trailing characters from the test string.
3. **indexTrim**: An index-based function that uses two pointers to remove leading/trailing characters.
4. **booleanTrim**: A function that uses string splitting and filtering to remove leading/trailing characters.
5. **spreadTrim**: A function that uses the spread operator to find the indices of non-matching characters and then removes them.
6. **substringTrim**: A simple function that repeatedly removes leading/trailing characters from the start and end of the test string.

**Options Compared**

The benchmark compares six different approaches for trimming leading/trailing characters:

1. **Regex Version (leaf)**: Uses a regular expression to match and remove leading/trailing characters.
2. **Index  Version (Jason Larke)**: Uses two pointers to iterate through the test string and remove matching characters.
3. **Boolean Filter Version (mbaer3000)**: Splits the test string into substrings using a boolean filter, removing any empty or null values.
4. **Spread Version (Robin F.)**: Uses the spread operator to find the indices of non-matching characters and then removes them.
5. **Substring Version (Pho3niX83)**: Repeatedly removes leading/trailing characters from the start and end of the test string.

**Pros and Cons**

Each approach has its strengths and weaknesses:

1. **Regex Version**: Fast, but may have performance issues with very long strings or complex patterns.
2. **Index  Version**: Efficient use of memory, but may be slower than regex-based approaches due to pointer manipulation.
3. **Boolean Filter Version**: Easy to understand and implement, but can be slower due to the overhead of string splitting and filtering.
4. **Spread Version**: Simple and concise implementation, but relies on the spread operator's behavior, which might not always be optimal.
5. **Substring Version**: Simple and straightforward, but may lead to unnecessary iterations if the test string is not properly optimized.

**Library Usage**

None of the provided functions explicitly use any external libraries. However, some approaches (e.g., regexTrim) rely on built-in JavaScript features, while others (e.g., indexTrim and substringTrim) are more low-level and do not utilize any external libraries.

**Special JS Feature/Syntax**

The benchmark does not specifically test or utilize any special JavaScript features or syntax beyond the standard language. However, it's worth noting that some implementations might be sensitive to specific browser or engine optimizations (e.g., WebAssembly or Just-In-Time compilation).

**Alternatives**

If you're interested in exploring other approaches for trimming leading/trailing characters, consider the following alternatives:

1. **Using a different data structure**: Instead of using strings, try working with arrays or buffers, which might be more efficient for large datasets.
2. **Employing more advanced algorithms**: Investigate algorithms like KMP (Knuth-Morris-Pratt) or Rabin-Karp, which can provide better performance for certain types of trimming tasks.
3. **Leveraging hardware acceleration**: Some browsers and engines offer hardware acceleration features that can be used to improve performance.

The benchmark test case provides a solid foundation for comparing different approaches, but feel free to experiment with new ideas and algorithms to optimize your own trimming tasks!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36

Browser/OS: Chrome 99 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Index Version (Jason Larke)	11997127.0 Ops/sec
Regex Version (leaf)	150161.0 Ops/sec
Boolean Filter Version (mbaer3000)	1363966.0 Ops/sec
Spread Version (Robin F.)	4151.9 Ops/sec
Substring Version (Pho3niX83)	10903854.0 Ops/sec

Related benchmarks:

Trimming leading/trailing characters (short match) (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: 2 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 27 days ago):