Benchmark: replaceAll vs regex replace vs split&join

Script Preparation code:

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
};

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('+');

Historical Performance Data aggregated from 41 community runs

Desktop Results:

Chrome 35 runs

split&join

11.3M/s

replace regex

10.4M/s

replace All

4.0M/s

Fastest: split&join (2.8x faster)

View exact numbers

✓ split&join: 11,266,885 ops/sec
• replace regex: 10,357,370 ops/sec
• replace All: 3,968,674 ops/sec

Firefox 6 runs

split&join

8.9M/s

replace regex

7.3M/s

replace All

3.1M/s

Fastest: split&join (2.9x faster)

View exact numbers

✓ split&join: 8,872,054 ops/sec
• replace regex: 7,258,580 ops/sec
• replace All: 3,082,716 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 9 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36

Browser/OS: Chrome 140 on Windows

View result in a separate tab

replace regex

2.3M/s

split&join

2.0M/s

replace All

1.1M/s

View exact numbers

Test name	Executions per second
✓ replace regex	2,334,376 Ops/sec
split&join	2,026,891 Ops/sec
replace All	1,121,608 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 provided Benchmark Definition and test cases.

**Overview**

The provided benchmark compares three approaches to replace or manipulate strings in JavaScript:

1. `replaceAll`: A custom implementation using the `replace` method with a regular expression.
2. `regex replace`: Using a regular expression with the `replace` method.
3. `split&join`: Splitting the string into an array and then joining it back together.

**Options Comparison**

The three approaches have different pros and cons:

1. **replaceAll** (custom implementation):
	* Pros: Potential for performance improvement due to optimized engine handling, as it's a native JavaScript method.
	* Cons: Requires modifying the `String.prototype` object, which can lead to unexpected behavior in other parts of the codebase.
2. `regex replace`:
	* Pros: Widely supported and well-documented, with many optimizations available in modern browsers.
	* Cons: May not be as performant as native implementations like `replaceAll`, especially for large strings.
3. `split&join`:
	* Pros: Simple to implement and easy to understand, making it a good choice for educational purposes or simple string manipulation tasks.
	* Cons: Inefficient compared to the other two methods, as it involves creating an array and then joining it back together.

**Library Usage**

There is no explicit library usage in this benchmark. However, note that modifying `String.prototype` in the `replaceAll` implementation could lead to conflicts with existing libraries or code that relies on this method.

**Special JS Feature/Syntax**

None of the provided test cases explicitly use any special JavaScript features or syntax beyond regular expressions.

**Alternatives**

Other alternatives for string manipulation in JavaScript include:

* Using built-in methods like `replace`, `split`, and `join` directly, without custom implementations.
* Utilizing libraries like Lodash or jQuery's DOM manipulation functions for more complex string operations.
* Implementing your own custom string manipulation algorithms using bitwise operators or other low-level techniques.

Keep in mind that while these alternatives may offer different trade-offs, the provided benchmark focuses on comparing the performance of `replaceAll`, `regex replace`, and `split&join` approaches.

replaceAll vs regex replace vs split&join (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

replace regex

replace All

split&join

Historical Performance Data aggregated from 41 community runs

Desktop Results:

Chrome 35 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

replaceAll vs regex replace vs split&join (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

replace regex

replace All

split&join

Historical Performance Data aggregated from 41 community runs

Desktop Results:

Chrome 35 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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