Benchmark: Trimming multiple leading/trailing characters, no set constructor overhead

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

var testArray = ['+'];
var testSet = new Set(testArray);
var testArray2 = ['+', '-'];
var testSet2 = new Set(testArray2);
var testArray3 = ['a', 'b', 'c', 'd', 'e'];
var testSet3 = new Set(testArray3);

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);​var testArray = ['+'];var testSet = new Set(testArray);var testArray2 = ['+', '-'];var testSet2 = new Set(testArray2);var testArray3 = ['a', 'b', 'c', 'd', 'e'];var testSet3 = new Set(testArray3);​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, testArray);
trimAny(testString, testArray);
Set single
trimAnySet(testString, testSet);
trimAnySet(testString, testSet);
Array double
trimAny(testString2, testArray2);
trimAny(testString2, testArray2);
Set double
trimAnySet(testString2, testSet2);
trimAnySet(testString2, testSet2);
Array 5
trimAny(testString3, testArray3);
trimAny(testString3, testArray3);
Set 5
trimAnySet(testString3, testSet3);
trimAnySet(testString3, testSet3);

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36 Edg/93.0.961.38

Browser/OS: Chrome 93 on Windows

View result in a separate tab

Test name	Executions per second
Array single	267136.5 Ops/sec
Set single	199973.2 Ops/sec
Array double	234984.5 Ops/sec
Set double	170225.2 Ops/sec
Array 5	78295.0 Ops/sec
Set 5	68348.0 Ops/sec

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

Let's dive into the benchmark.

The provided benchmark measures the performance of two string trimming functions: trimAny and trimAnySet, in different scenarios with various data structures (arrays and sets).

What is tested?

The benchmark tests the execution speed of the trimAny and trimAnySet functions on a set of predefined test strings. The test strings are generated by repeating specific characters ('+', '-', 'a' to 'g') in varying lengths.

The functions being tested:

trimAny: takes two arguments, str (the input string) and chars (an array of characters to trim from the start or end of the string).
trimAnySet: similar to trimAny, but uses a Set data structure instead of an array for chars.

Options compared

The benchmark compares two approaches:

Array-based trimming (trimAny): uses an array of characters to trim from the start or end of the string.
Set-based trimming (trimAnySet): uses a Set data structure to store and look up the characters to trim.

Pros and cons

Array-based trimming (trimAny):
- Pros: potentially faster, as arrays are often optimized for lookup and iteration.
- Cons: may require more memory allocation and garbage collection due to the dynamic array.
Set-based trimming (trimAnySet):
- Pros: potentially more efficient in terms of memory usage, as Sets have faster lookup times.
- Cons: may be slower due to the overhead of creating and managing a Set, especially for larger inputs.

Other considerations

The benchmark does not consider other factors that might impact performance, such as:
- String encoding (e.g., UTF-8 vs. ASCII).
- Platform-specific optimizations or limitations.
- Browser-specific quirks or inconsistencies.
The test strings are designed to cover various edge cases, but may not represent real-world usage scenarios.

Library and features

No specific JavaScript library is mentioned in the benchmark definition or execution code. However, the use of Set data structures suggests that modern JavaScript engines (e.g., V8) have optimized support for this data structure.

Special JS feature or syntax

The benchmark does not explicitly test any special JavaScript features or syntax.

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

The provided benchmark measures the performance of two string trimming functions: `trimAny` and `trimAnySet`, in different scenarios with various data structures (arrays and sets).

**What is tested?**

The benchmark tests the execution speed of the `trimAny` and `trimAnySet` functions on a set of predefined test strings. The test strings are generated by repeating specific characters ('+', '-', 'a' to 'g') in varying lengths.

The functions being tested:

* `trimAny`: takes two arguments, `str` (the input string) and `chars` (an array of characters to trim from the start or end of the string).
* `trimAnySet`: similar to `trimAny`, but uses a `Set` data structure instead of an array for `chars`.

**Options compared**

The benchmark compares two approaches:

1. **Array-based trimming (`trimAny`)**: uses an array of characters to trim from the start or end of the string.
2. **Set-based trimming (`trimAnySet`)**: uses a `Set` data structure to store and look up the characters to trim.

**Pros and cons**

* **Array-based trimming (`trimAny`)**:
	+ Pros: potentially faster, as arrays are often optimized for lookup and iteration.
	+ Cons: may require more memory allocation and garbage collection due to the dynamic array.
* **Set-based trimming (`trimAnySet`)**:
	+ Pros: potentially more efficient in terms of memory usage, as `Sets` have faster lookup times.
	+ Cons: may be slower due to the overhead of creating and managing a `Set`, especially for larger inputs.

**Other considerations**

* The benchmark does not consider other factors that might impact performance, such as:
	+ String encoding (e.g., UTF-8 vs. ASCII).
	+ Platform-specific optimizations or limitations.
	+ Browser-specific quirks or inconsistencies.
* The test strings are designed to cover various edge cases, but may not represent real-world usage scenarios.

**Library and features**

No specific JavaScript library is mentioned in the benchmark definition or execution code. However, the use of `Set` data structures suggests that modern JavaScript engines (e.g., V8) have optimized support for this data structure.

**Special JS feature or syntax**

The benchmark does not explicitly test any special JavaScript features or syntax.

Related benchmarks:

Trimming multiple leading/trailing characters, no set constructor overhead (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

Set 5

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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