Benchmark: (vanilla) replaceAll vs regex replace vs split&join

Tests:

replace regex
"this {a} is {a} it".replace(/\{a\}/g, "+");
replace All
"this {a} is {a} it".replaceAll("{a}", "+");
split&join
"this {a} is {a} it".split('{a}').join('+');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
replace regex
replace All
split&join

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Linux

View result in a separate tab

Test name	Executions per second
replace regex	2514235.8 Ops/sec
replace All	4272164.0 Ops/sec
split&join	1885869.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):

LLMs can make mistakes. Check important info.

The JSON benchmark represents a comparison of three different string manipulation techniques provided in JavaScript for replacing occurrences of a substring within a string. The techniques tested are:

1. **Regular Expression Replacement (`replace regex`)**:
   ```javascript
   "this {a} is {a} it".replace(/\\{a\\}/g, "+");
   ```
   - This method utilizes a regular expression to identify all occurrences of the substring `{a}` in the string and replaces them with a `+`.
   - **Pros**:
     - Powerful and flexible: Regular expressions can match more complex patterns than simple substring replacements.
     - Efficient for large strings with multiple occurrences.
   - **Cons**:
     - Can be less readable and harder to maintain, especially for those unfamiliar with regex syntax.
     - May involve a performance overhead related to parsing the regex pattern.

2. **String.prototype.replaceAll (`replace All`)**:
   ```javascript
   "this {a} is {a} it".replaceAll("{a}", "+");
   ```
   - Introduced in ECMAScript 2021, this method directly replaces all occurrences of the defined substring `{a}` with `+` without needing to define a regex.
   - **Pros**:
     - Simplicity: Easier to read and understand for developers not well-versed in regex.
     - Directly designed for replacing all occurrences without additional flags.
   - **Cons**:
     - Still relatively new; may not be supported in older browsers or environments.
     - May not perform as well as regex in some complex scenarios, particularly with more complex patterns.

3. **Split and Join (`split&join`)**:
   ```javascript
   "this {a} is {a} it".split('{a}').join('+');
   ```
   - This method splits the string into an array of substrings using `{a}` as the delimiter and then joins them back together with `+`.
   - **Pros**:
     - Very straightforward to understand and implement.
     - Useful if additional transformations or operations need to be performed on the resulting substrings.
   - **Cons**:
     - Potentially less efficient than the other methods, as it involves creating an array which has overhead for memory usage and processing time.
     - Only works with exact substring matches and does not support patterns or regex.

### Performance Results
The benchmark results show the **executions per second** for each approach when tested under similar conditions on Chrome 135 (Windows):

- **Regular Expression Replacement**: 9,971,295 executions/second
- **Split and Join**: 8,887,752 executions/second
- **Replace All**: 5,850,333 executions/second

### Considerations
- The choice between these methods can depend on specific requirements:
  - If you need complex pattern matching, regular expressions are the best choice despite their complexity.
  - For simple cases and improved readability, `replaceAll` is ideal if environment compatibility allows it.
  - The `split&join` method is clear and intuitive but may be less optimal in terms of performance.
  
### Alternatives
Some other alternatives for string manipulation in JavaScript include:
- **String.prototype.replace** with a function: Allows customizing replacement logic beyond basic substitution.
- **Template literals**: For combining variables into strings without needing replacements, though they don't replace substrings.

Each method has its context and usage scenarios, and the choice often comes down to personal or team preferences, as well as the performance requirements of the application being developed.

Related benchmarks:

(vanilla) replaceAll vs regex replace vs split&join (version: 1)

Comparing performance of: replace regex vs replace All vs split&join

Created: 9 months ago by: Guest

Jump to the latest result

replace regex

replace All

split&join

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):