Benchmark: replaceAll vs regex replace vs string 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 is it".replace(/ /g, "+");
replace All
"this is it".replaceAll(" ", "+");
string split join
"this is it".split(" ").join("+");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
replace regex
replace All
string split join

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/132.0.0.0 Safari/537.36 Edg/132.0.0.0

Browser/OS: Chrome 132 on Mac OS X 10.15.7

View result in a separate tab

string split join

14.0M/s

replace regex

11.5M/s

replace All

6.1M/s

View exact numbers

Test name	Executions per second
✓ string split join	14,006,131 Ops/sec
replace regex	11,494,558 Ops/sec
replace All	6,145,420 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark is designed to compare three different approaches for replacing or manipulating strings:

1. `replaceAll`: a custom implementation of string replacement using a loop.
2. `replace`: a standard JavaScript method for regular expression-based string replacement.
3. `split` and `join`: methods for splitting a string into an array and then joining it back together with a separator.

**Options Compared**

The three options are compared in terms of performance, specifically the number of executions per second on a given device platform (Desktop).

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. `replaceAll`:
	* Pros: Simple to understand and implement, might be faster for small strings due to reduced overhead from regular expressions.
	* Cons: Inefficient for large strings due to the loop overhead, may not work correctly with edge cases or Unicode characters.
2. `replace`:
	* Pros: Standard JavaScript method, well-documented, and widely supported; can handle edge cases and Unicode characters.
	* Cons: May be slower than custom implementations due to regular expression compilation and matching overhead.
3. `split` and `join`:
	* Pros: Efficient for large strings since they only require two operations (split and join), relatively fast.
	* Cons: Requires an extra step (array creation), might not be as efficient for very small strings.

**Library Used**

None, the benchmark uses standard JavaScript methods (`replaceAll`, `replace`, `split`, and `join`) without any external libraries.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. The focus is on comparing different string manipulation approaches.

**Other Alternatives**

If you were to design an alternative benchmark, you might consider:

1. Comparing the performance of custom implementations using different data structures (e.g., arrays vs. linked lists) or algorithms (e.g., brute force vs. optimized searching).
2. Investigating the impact of various factors on string manipulation performance, such as:
	* String length
	* Character encoding
	* Frequency of replacements or manipulations
	* Device platform and operating system differences

Feel free to ask if you'd like me to elaborate on any of these points!

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

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

Created: 2 years ago by: Guest

Go to the latest result

replace regex

replace All

string split join

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 string split join (version: 0)

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

Created: 2 years ago by: Guest

Go to the latest result

replace regex

replace All

string split join

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 string split join`