Benchmark: replace vs. replaceAll

Script Preparation code:

window.data = `
  <html>
    <body>
      <h1>testing</h1>
      &#60418; code here &#60419;
      <div>test</div>
       &#60418; code here &#60419;
       <div>test</div>
       <p><span>testing</span></p>
      &#60418; code here &#60419;
    </body>
  </html>
`
window.reg1 = /&#60418;/g
window.reg2 = /&#60419;/g

Tests:

Variable replace
data .replace(reg1, '') .replace(reg2, '')
Replace
data .replace(//g, '') .replace(//g, '')
ReplaceAll
data .replaceAll('', '') .replaceAll('', '')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Variable replace
Replace
ReplaceAll

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Variable replace	2215343.2 Ops/sec
Replace	3105862.2 Ops/sec
ReplaceAll	2621596.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Purpose:**
The purpose of this benchmark is to compare the performance of three different approaches for replacing specific strings in a string.

**Tested Options:**

1. **`replace()`**: This option uses the `String.prototype.replace()` method with two separate calls, each with a different regular expression (`reg1` and `reg2`) and an empty replacement string.
2. **`replaceAll()`**: This option uses the `String.prototype.replaceAll()` method, which is not supported in all browsers. It's used here to test its performance on modern browsers that support it.
3. **Variable replace**: This option uses a variable assignment (`window.reg1 = /&#60418;/g`) and then calls the `replace()` method with this variable.

**Pros and Cons of each approach:**

* `replace()`: This is the most widely supported method, but it requires two separate calls, which can lead to slower performance compared to other methods.
* `replaceAll()`: This method is not supported in older browsers, so its performance may vary depending on the target browser. However, modern browsers like Chrome 114 support it, making it a good option for testing.
* Variable replace: Using a variable assignment can make the code more readable and maintainable, but it also adds overhead due to the need to assign the regular expression to a variable.

**Library/Functions Used:**
None of the test cases explicitly use any external libraries. However, some modern browsers like Chrome 114 support `replaceAll()`, which is implemented in the browser's JavaScript engine.

**Special JS Features/Syntax:**
No special features or syntax are used in this benchmark that would require specific knowledge to understand.

**Benchmark Preparation Code:**
The preparation code creates a string (`data`) with several instances of the strings to be replaced (`&#60418;` and `&#60419;`). It also sets up two regular expressions (`reg1` and `reg2`) for replacement.

To run this benchmark, you would need to create a new test case in MeasureThat.net with the provided JSON data and script preparation code. The individual test cases are already defined in the "Individual test cases" section of the benchmark definition.

**Alternative Approaches:**
Other approaches that could be used for string replacement include:

* Using `substr()` or `slice()` to manually remove characters
* Using a library like Lodash's `replace()` function
* Using a more modern browser-specific feature, such as WebAssembly's `text` module

However, these alternatives may not be supported in all browsers or may require additional setup, making the original approach using `replace()`, `replaceAll()`, and variable assignment a good starting point for benchmarking.

Related benchmarks:

replace vs. replaceAll (version: 0)

Uses 2 replaces

Comparing performance of: Variable replace vs Replace vs ReplaceAll

Created: one year ago by: Registered User

Jump to the latest result

Variable replace

Replace

ReplaceAll

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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