Benchmark: Trimming multiple leading/trailing characters

Script Preparation code:

var TestString = '+'.repeat(200) + '='.repeat(20000) + '+'.repeat(200);
var TestString2 = '-'.repeat(200) + '='.repeat(20000) + '+'.repeat(200);
var TestString3 = 'a'.repeat(200) + 'b'.repeat(200) + 'c'.repeat(200) + 'd'.repeat(200) + 'e'.repeat(200) + 'f'.repeat(200) + 'g'.repeat(200) + 'h'.repeat(200) + 'i'.repeat(200) + 'j'.repeat(200) + 'k'.repeat(200) + 'l'.repeat(200);

function trimAnySet(str, chars) {
    var start = 0, 
        end = str.length;

    while(start < end && chars.has(str[start]))
        ++start;

    while(end > start && chars.has(str[end - 1]))
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

function trimAny(str, chars) {
    var start = 0, 
        end = str.length;

    while(start < end && chars.indexOf(str[start]) >= 0)
        ++start;

    while(end > start && chars.indexOf(str[end - 1]) >= 0)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

​x
 
var TestString = '+'.repeat(200) + '='.repeat(20000) + '+'.repeat(200);var TestString2 = '-'.repeat(200) + '='.repeat(20000) + '+'.repeat(200);var TestString3 = 'a'.repeat(200) + 'b'.repeat(200) + 'c'.repeat(200) + 'd'.repeat(200) + 'e'.repeat(200) + 'f'.repeat(200) + 'g'.repeat(200) + 'h'.repeat(200) + 'i'.repeat(200) + 'j'.repeat(200) + 'k'.repeat(200) + 'l'.repeat(200);​function trimAnySet(str, chars) {    var start = 0,         end = str.length;​    while(start < end && chars.has(str[start]))        ++start;​    while(end > start && chars.has(str[end - 1]))        --end;​    return (start > 0 || end < str.length) ? str.substring(start, end) : str;}​function trimAny(str, chars) {    var start = 0,         end = str.length;​    while(start < end && chars.indexOf(str[start]) >= 0)        ++start;​    while(end > start && chars.indexOf(str[end - 1]) >= 0)        --end;​    return (start > 0 || end < str.length) ? str.substring(start, end) : str;}

Tests:

Array single
trimAny(TestString, ['+']);
trimAny(TestString, ['+']);
Set single
trimAnySet(TestString, new Set(['+']));
trimAnySet(TestString, new Set(['+']));
Array double
trimAny(TestString2, ['+', '-']);
trimAny(TestString2, ['+', '-']);
Set double
trimAnySet(TestString2, new Set(['+', '-']));
trimAnySet(TestString2, new Set(['+', '-']));
Array 5
trimAny(TestString3, ['a', 'b', 'c', 'd', 'e']);
trimAny(TestString3, ['a', 'b', 'c', 'd', 'e']);

Set 5

trimAnySet(TestString3, new Set(['a', 'b', 'c', 'd', 'e']));

 
trimAnySet(TestString3, new Set(['a', 'b', 'c', 'd', 'e']));

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
Array single
Set single
Array double
Set double
Array 5
Set 5

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; rv:92.0) Gecko/20100101 Firefox/92.0

Browser/OS: Firefox 92 on Windows

View result in a separate tab

Test name	Executions per second
Array single	132651.1 Ops/sec
Set single	65385.8 Ops/sec
Array double	126659.6 Ops/sec
Set double	64518.2 Ops/sec
Array 5	75613.6 Ops/sec
Set 5	32849.0 Ops/sec

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

Measuring the performance of JavaScript trimming functions is an interesting benchmark.

What's being tested?

The provided benchmark tests the performance of two different trimming functions:

trimAny(str, chars): This function takes a string and an array of characters to trim from the start and end of the string.
trimAnySet(str, charsSet): This function is similar to trimAny, but it uses a Set data structure instead of an array for the characters.

Options being compared

The benchmark compares the performance of these two trimming functions with different input scenarios:

Single character trimming: Testing the performance of both functions when only one character is used for trimming.
Double character trimming: Testing the performance of both functions when two characters are used for trimming.
Trimming a large set of characters: Testing the performance of both functions when a large array or set of characters is used for trimming.

Pros and cons

Here's a brief overview of each function's pros and cons:

trimAny(str, chars): This function has a simple and straightforward approach. However, it uses the indexOf() method to find the character in the chars array, which may lead to slower performance compared to using a Set.
trimAnySet(str, charsSet): This function uses a Set, which can provide faster lookup times than an array. However, it requires more memory and CPU cycles to create and maintain the set.

Library and purpose

The two trimming functions rely on the following libraries and data structures:

indexOf() method: A built-in JavaScript method for finding the position of a value in an array or string.
Set data structure: A built-in JavaScript data structure for storing unique values. In this benchmark, it's used to efficiently check if a character is present in the set.

Special JS feature or syntax

This benchmark doesn't rely on any special JavaScript features or syntax. However, it does use some basic string manipulation techniques and array/set operations, which are widely supported across different browsers and environments.

Other alternatives

If you're interested in exploring other trimming functions or approaches, here are a few alternatives:

Using regular expressions (regex) to trim strings: This approach can be more efficient than using arrays or sets, but it may also lead to slower performance for very large inputs.
Implementing a custom trimming algorithm: Depending on the specific requirements and constraints of your use case, you might want to explore implementing a custom trimming algorithm that's optimized for your specific needs.

Overall, this benchmark provides a good starting point for comparing the performance of different trimming functions in JavaScript.

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript trimming functions is an interesting benchmark.

**What's being tested?**

The provided benchmark tests the performance of two different trimming functions:

1. `trimAny(str, chars)`: This function takes a string and an array of characters to trim from the start and end of the string.
2. `trimAnySet(str, charsSet)`: This function is similar to `trimAny`, but it uses a `Set` data structure instead of an array for the characters.

**Options being compared**

The benchmark compares the performance of these two trimming functions with different input scenarios:

* Single character trimming: Testing the performance of both functions when only one character is used for trimming.
* Double character trimming: Testing the performance of both functions when two characters are used for trimming.
* Trimming a large set of characters: Testing the performance of both functions when a large array or set of characters is used for trimming.

**Pros and cons**

Here's a brief overview of each function's pros and cons:

* `trimAny(str, chars)`: This function has a simple and straightforward approach. However, it uses the `indexOf()` method to find the character in the `chars` array, which may lead to slower performance compared to using a `Set`.
* `trimAnySet(str, charsSet)`: This function uses a `Set`, which can provide faster lookup times than an array. However, it requires more memory and CPU cycles to create and maintain the set.

**Library and purpose**

The two trimming functions rely on the following libraries and data structures:

* `indexOf()` method: A built-in JavaScript method for finding the position of a value in an array or string.
* `Set` data structure: A built-in JavaScript data structure for storing unique values. In this benchmark, it's used to efficiently check if a character is present in the set.

**Special JS feature or syntax**

**Other alternatives**

If you're interested in exploring other trimming functions or approaches, here are a few alternatives:

* Using regular expressions (regex) to trim strings: This approach can be more efficient than using arrays or sets, but it may also lead to slower performance for very large inputs.
* Implementing a custom trimming algorithm: Depending on the specific requirements and constraints of your use case, you might want to explore implementing a custom trimming algorithm that's optimized for your specific needs.

Overall, this benchmark provides a good starting point for comparing the performance of different trimming functions in JavaScript.

Related benchmarks:

Trimming multiple leading/trailing characters (version: 0)

Comparing performance of: Array single vs Set single vs Array double vs Set double vs Array 5 vs Set 5

Created: 3 years ago by: Guest

Jump to the latest result

Array single

Set single

Array double

Set double

Array 5