Benchmark: regex vs double replace vs substring

Script Preparation code:

var testStr = '[marketCode::US]';
var outputStr = '';

Tests:

regex
outputStr = testStr.replace(/[\[\]]/g, '');
double replace
outputStr = testStr.replace('[', '').replace(']', '');
substring
outputStr = testStr.substring(1, testStr.length - 1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex
double replace
substring

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 144 on Android

View result in a separate tab

Test name	Executions per second
regex	3620926.0 Ops/sec
double replace	4179819.5 Ops/sec
substring	6493520.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition json and analyze what's being tested.

**What is being tested?**

MeasureThat.net is testing three different approaches to remove square brackets (`[`) and curly brackets (`{`) from a given string `testStr`:

1. **Regular Expressions (regex)**: The `replace()` method uses regex to match and replace `[\\[\\]]/g`, which matches any of the characters `[`, `\\`, or `]`.
2. **Double Replace**: The `replace()` method is called twice, once for each bracket type, without using regex: `testStr.replace('[', '')` followed by `testStr.replace(']', '')`.
3. **Substring**: The `substring()` method extracts a portion of the string, starting from index 1 and ending at the last character (`testStr.length - 1`).

**Options Comparison**

Here's a comparison of the three approaches:

*   **Regex (regex)**:
    *   Pros: Can match multiple bracket types in a single operation.
    *   Cons: Can be slower due to the overhead of regex processing and can be more complex to read and maintain.
*   **Double Replace**: 
    *   Pros: Can be faster since it only involves two `replace()` operations, which are likely optimized for performance. It's also simpler to understand than regex.
    *   Cons: Requires calling `replace()` twice, which may lead to overhead due to function call and string concatenation operations.
*   **Substring**:
    *   Pros: Generally the fastest approach since it only requires a single method call with simple arithmetic.
    *   Cons: May not be as efficient for strings that contain multiple brackets or if you need to remove other characters.

**Library and Special JS Feature**

There is no library being used in this benchmark, but MeasureThat.net does use JavaScript-specific features like `var` declarations and the `replace()` method with regex patterns.

**Other Alternatives**

Some alternative approaches could be:

*   **Using a custom function**: Instead of using built-in methods, you could create your own function to remove brackets. This might provide more control over the removal process but would likely require additional implementation.
*   **Using a library or module**: Depending on the specific requirements of your use case, there may be libraries or modules available that can help with bracket removal. However, MeasureThat.net's focus is on comparing JavaScript language features.

Here's an example of how you might write this benchmark in JavaScript using Node.js:

```javascript
const { measure } = require('measurethat');

async function benchmark() {
    const testStr = '[marketCode::US]';
    let outputStr;

// regex approach
    console.log("regex");
    process.stdout.write(testStr);
    outputStr = testStr.replace(/\[|\]/g, '');
    console.log(outputStr);

// double replace approach
    console.log("\ndouble replace");
    process.stdout.write(testStr);
    outputStr = testStr.replace('[', '').replace(']', '');
    console.log(outputStr);

// substring approach
    console.log("\nsubstring");
    outputStr = testStr.substring(1, testStr.length - 1);
}

measure.benchmark(benchmark);
```

This code uses the `measurethat` library to create a benchmark and runs the three approaches sequentially. The results will be displayed in an interactive environment.

**Conclusion**

MeasureThat.net provides a useful tool for comparing different JavaScript language features, such as string manipulation methods like regex, double replace, and substring. By running this benchmark, developers can see which approach is fastest on their specific hardware configuration.

Related benchmarks:

regex vs double replace vs substring (version: 0)

Comparing performance of: regex vs double replace vs substring

Created: 4 years ago by: Guest

Jump to the latest result

regex

double replace

substring

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):